gitpane 1.0.0__py3-none-any.whl

gitpane/controller/setting_controller.py

@@ -0,0 +1,592 @@
+"""Edit the shared settings of GitPane, starting with the Git it runs."""
+
+from __future__ import annotations
+
+import os
+import sys
+import uuid
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Signal
+from shiboken6 import isValid
+
+from gitpane.account.credential_manager import ignore_line
+from gitpane.account.ssh import effective_source
+from gitpane.config import SharedText
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.repository_value import RepositoryFailure, RequestIdentity
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.system.desktop_icon_fact import read_session_desktop_icon_facts
+from gitpane.system.desktop_shortcut import create_installed_desktop_shortcut
+from gitpane.system.linux_distribution import DistributionFamily, DistributionRelease
+from gitpane.tool.difftool import DifftoolRecipe
+from gitpane.tool.git_executable import detect_git_candidates
+from gitpane.tool.kdiff3 import detect_kdiff3_filename
+from gitpane.tool.kdiff3_install import kdiff3_install_line
+from gitpane.tool.mergetool_recipe import MERGETOOL_COMMAND_PREFERENCE_KEY, MERGETOOL_FILENAME_PREFERENCE_KEY, MergetoolRecipe
+from gitpane.transport.push_tracking import push_tracking_choice, save_push_tracking_choice
+from gitpane.ui.console.error_dialog import ErrorDialog
+from gitpane.ui.setting.account_page import ACCOUNTS_PAGE_NAME, AccountPage
+from gitpane.ui.setting.git_setting_widget import GitSettingWidget
+from gitpane.ui.setting.setting_dialog import GIT_AVAILABLE_TEMPLATE, SSH_PAGE_NAME, SettingDialog
+from gitpane.ui.setting.ssh_widget import SshWidget
+from gitpane.ui.setting.utility_page import UtilityPage
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from gitpane.account.ssh import SshService, SshVerification
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.window_activation import WindowActivationFilter
+    from gitpane.git_config.git_setting import GitSettingService
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.sequencer.mergetool import MergetoolService
+    from gitpane.system.desktop_icon_support import DesktopIconFacts
+    from gitpane.system.desktop_shortcut import ShortcutReport
+    from gitpane.tool.git_executable import GitExecutableValidator
+    from gitpane.tool.system_editor_default import SystemEditorDefault
+    from gitpane.tool.terminal_recipe import TerminalRegistry
+    from gitpane.transport.push_tracking import PushTrackingChoice
+
+SETTING_FAILED_DRAFTS_TEXT = "Settings could not all be saved. Your failed drafts are retained."
+
+
+@dataclass(frozen=True)
+class WaitingOpening:
+    """One opening asked before the startup check of Git answered, with the Git it was asked with.
+
+    ``checks_folder`` says that the opening, once released, asks whether its folder exists before Git reads it; only the
+    openings of the welcome window do, a clone's destination being known to exist.
+    """
+
+    identity: RequestIdentity
+    repository_dir: str
+    git_filename: str
+    checks_folder: bool = False
+
+
+class SettingController(QObject):
+    """The Settings window with its drafts, and the checks of the Git GitPane runs: at startup, after a change made elsewhere, and from the window."""
+
+    # Settings window just built, its accounts page, the session that asked (or None), the repository it opened for (or None):
+    # the accounts page is filled and connected while the window is being built, before its own buttons are connected.
+    setting_opened = Signal(object, object, object, object)
+    # The startup check found no Git, or none that works: the welcome window says so and opens Settings, where a failure
+    # of the last Git tried is shown next.
+    git_missing = Signal()
+    # An opening asked during the startup check of Git, released with the Git that check accepted: the opening
+    # controller goes on with it.
+    waiting_opening_released = Signal(object)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter,
+                 history_read_controller: HistoryReadController, preference: PreferenceStore, repository: GitRepository, git_setting_service: GitSettingService, ssh: SshService, mergetool: MergetoolService,
+                 diagnostic_log: DiagnosticLog | None, terminal_registry: TerminalRegistry, validator: GitExecutableValidator, system_editor_default: SystemEditorDefault,
+                 desktop_shortcut: Callable[[], ShortcutReport] = create_installed_desktop_shortcut,
+                 desktop_icon_facts: Callable[[], DesktopIconFacts] = read_session_desktop_icon_facts, distribution_family: DistributionFamily = DistributionFamily.UNKNOWN,
+                 distribution_release: DistributionRelease = DistributionRelease.OTHER, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers Settings works with; the wiring builds it after the history read controller, and the accounts, the clone forms and the welcome learn from its signals what it opened or found.
+
+        ``desktop_shortcut`` writes the desktop shortcut of the running installation when the Utilities page asks for
+        it; tests give their own, which writes only in their temporary folder. ``desktop_icon_facts`` reads from the
+        session whether the desktop can show the shortcut's icon, each time the Utilities page is shown, on the page's
+        worker thread; tests give their own, which reads nothing from the machine. ``diagnostic_log``, when a ``--log``
+        journal is kept, also receives the errors nobody expects of these two workers. ``system_editor_default`` keeps the
+        text editor the system names, which the editor detection follows while no editor choice is saved.
+        ``distribution_family`` and ``distribution_release`` name the Linux distribution of the session, read once by the
+        wiring, so the help and the refusals of a missing diff or merge tool say how to install KDiff3 there.
+        """
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.window_activation_controller = window_activation_controller
+        self.history_read_controller = history_read_controller
+        self.preference = preference
+        self.repository = repository
+        self.git_setting_service = git_setting_service
+        self.ssh = ssh
+        self.mergetool = mergetool
+        self.diagnostic_log = diagnostic_log
+        self.terminal_registry = terminal_registry
+        self.validator = validator
+        self.system_editor_default = system_editor_default
+        self.desktop_shortcut = desktop_shortcut
+        self.desktop_icon_facts = desktop_icon_facts
+        self.distribution_family = distribution_family
+        self.distribution_release = distribution_release
+        self.setting_session_id = uuid.uuid4().hex
+        self.setting_generation = 0
+        self.setting_identity: RequestIdentity | None = None
+        self.save_requested = False
+        self.startup_identity: RequestIdentity | None = None
+        self.launch_validation_identity: RequestIdentity | None = None
+        # The Git the open Settings draft has just validated, and the one a save in progress is writing with that proof.
+        self.setting_validated_git_filename = ""
+        self.saving_validated_git_filename = ""
+        # Set while the check in progress was asked by Verify Git, the only check whose success is announced with a box.
+        self.setting_verify_clicked = False
+        # Warning about the tools folder of the Git the current Settings check accepts; cleared with that check.
+        self.setting_tools_folder_warning = ""
+        self.candidate_filenames: list[str] = []
+        # Openings asked while the startup check of Git is still running, with the Git each one was asked with.
+        self.waiting_opening_by_session: dict[str, WaitingOpening] = {}
+
+    def _validate_selected_git(self, git_filename: str) -> None:
+        """Check a Git accepted elsewhere, in a session of its own, so a slow answer cannot revive an older choice."""
+        if self.launch_validation_identity is not None:
+            self.validator.cancel(self.launch_validation_identity.session_id)
+        self.launch_validation_identity = RequestIdentity(uuid.uuid4().hex)
+        self.validator.validate(git_filename, self.launch_validation_identity)
+
+    def show_setting(self, session_id: str | None = None, *, section: str | None = None) -> SettingDialog | None:
+        """Open shared settings and reveal a requested section without discarding an existing draft."""
+        if session_id is not None and not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        if self.session_registry_controller.setting_dialog is not None:
+            self.session_registry_controller.setting_dialog.showNormal()
+            self.session_registry_controller.setting_dialog.raise_()
+            self.session_registry_controller.setting_dialog.activateWindow()
+            if section == "mergetool":
+                self.session_registry_controller.setting_dialog.show_mergetool_setting()
+            if section == "editor":
+                self.session_registry_controller.setting_dialog.show_editor_setting()
+            if section == "accounts":
+                self.session_registry_controller.setting_dialog.show_page(ACCOUNTS_PAGE_NAME)
+            return self.session_registry_controller.setting_dialog
+        mergetool_filename = self.preference.initialize_mergetool(save_detected=False)
+        merge_warning = self.preference.warning
+        difftool_filename = self.preference.initialize_difftool(save=False)
+        # The notice asks for a Save only when the merge tool shown would not be used without one. A detected KDiff3 is used
+        # as it is by the conflict action, so it gets no notice even though it is not saved yet.
+        detected_kdiff3_filename = detect_kdiff3_filename(sys.platform)
+        mergetool_suggested = bool(mergetool_filename) and mergetool_filename not in (self.preference.value_by_key[MERGETOOL_FILENAME_PREFERENCE_KEY], detected_kdiff3_filename)
+        context = self.session_registry_controller.session_by_id[session_id].repository_context if session_id is not None else None
+        editor_recipe = self.preference.initialize_editor(repository_dirs=(context.repository_dir,) if context is not None else (),
+                                                          system_editor_id=self.system_editor_default.system_editor_id)
+        # Read again for the next opening and for Show in text editor, so a default editor changed on the desktop is followed.
+        self.system_editor_default.request_read()
+        git_setting_widget = self._git_setting_widget(context)
+        account_page = AccountPage(context.repository_dir if context is not None else None)
+        # The form gets only the saved client: a detected one shown there would be saved by the next Save.
+        ssh_widget = SshWidget(self.ssh.saved_configuration(), *self._effective_ssh())
+        utility_page = UtilityPage(self.desktop_shortcut, self.desktop_icon_facts, log_line=self.diagnostic_log.write_line if self.diagnostic_log is not None else ignore_line)
+        dialog = SettingDialog(str(self.preference.value_by_key["git_filename"]) or self.repository.git_filename,
+                               difftool_filename=difftool_filename, difftool_command=str(self.preference.value_by_key["difftool_command"]), git_setting_widget=git_setting_widget,
+                               account_page=account_page, ssh_widget=ssh_widget, utility_page=utility_page, mergetool_filename=mergetool_filename,
+                               mergetool_command=str(self.preference.value_by_key[MERGETOOL_COMMAND_PREFERENCE_KEY]), mergetool_suggested=mergetool_suggested,
+                               editor_recipe=editor_recipe, kdiff3_install_line="" if detected_kdiff3_filename else kdiff3_install_line(sys.platform, self.distribution_family, self.distribution_release))
+        # Settings are shared by every window and have no Qt parent; they open over the window that asked for them.
+        dialog.placement_anchor = self.session_registry_controller.window_by_session.get(session_id) if session_id is not None else next(iter(self.session_registry_controller.welcome_by_session.values()), None)
+        self.session_registry_controller.setting_dialog = dialog
+        ssh_widget.verification_requested.connect(self._verify_ssh)
+        self.setting_opened.emit(dialog, account_page, session_id, context)
+        dialog.validation_requested.connect(self._validate_setting)
+        dialog.git_verify_requested.connect(self._verify_setting)
+        dialog.detection_requested.connect(self._detect_setting)
+        dialog.draft_changed.connect(self._invalidate_setting)
+        dialog.finished.connect(self._close_setting)
+        dialog.installEventFilter(self.window_activation_controller)
+        if self.repository.git_version:
+            dialog.status_label.setText(GIT_AVAILABLE_TEMPLATE.format(version=self.repository.git_version))
+        if self.preference.warning:
+            dialog.status_label.setText(self.preference.warning)
+        if merge_warning:
+            dialog.status_label.setText(merge_warning)
+        # Modal for the whole application on every system: no other GitPane window can come in front of Settings or take
+        # a click while it is open, and the windows it opens are modal over it. On macOS AppKit keeps a running modal
+        # session above the application's other windows, and puts it back to the normal level while another
+        # application is active, so Settings never floats above the browser of a sign-in.
+        open_window_modal(dialog, blocks_application=True)
+        if section == "mergetool":
+            dialog.show_mergetool_setting()
+        if section == "editor":
+            dialog.show_editor_setting()
+        if section == "accounts":
+            dialog.show_page(ACCOUNTS_PAGE_NAME)
+        return dialog
+
+    def _git_setting_widget(self, context: RepositoryContext | None) -> GitSettingWidget:
+        """Build the Git page; opened from a repository, it also offers that repository's tracking choice, kept in the preferences file.
+
+        The choice is keyed by the shared Git folder of the repository Settings was opened from, so linked worktrees share
+        it and no other repository's entry is touched.
+        """
+        if context is None:
+            return GitSettingWidget(self.git_setting_service, None, self.repository.git_filename)
+
+        def save_push_tracking(choice: PushTrackingChoice) -> None:
+            """Keep the choice for the repository Settings was opened from."""
+            save_push_tracking_choice(self.preference, context.common_git_dir, choice)
+
+        return GitSettingWidget(self.git_setting_service, context, self.repository.git_filename,
+                                push_tracking_choice=push_tracking_choice(self.preference, context.common_git_dir), save_push_tracking=save_push_tracking)
+
+    def _verify_ssh(self, save: bool = False) -> None:
+        """Verify a captured SSH candidate and discard results from a closed Settings view.
+
+        With Executable empty the candidate is the client operations use now, so Verify is useful without any setting;
+        that check never marks the draft as verified.
+        """
+        dialog = self.session_registry_controller.setting_dialog
+        if dialog is None or dialog.ssh_widget.request_id:
+            return
+        widget = dialog.ssh_widget
+        configuration = widget.verification_configuration()
+        generation = self.setting_generation
+        widget.set_verifying()
+
+        def complete(result: SshVerification) -> None:
+            """Continue an explicit Save only if its original candidate is still current."""
+            if self.session_registry_controller.setting_dialog is not dialog or not isValid(widget):
+                return
+            widget.show_result(result)
+            if save and result.succeeded and generation == self.setting_generation:
+                self._validate_setting(dialog.typed_git_filename(), True)
+
+        widget.request_id = self.ssh.verify(configuration, complete)
+
+    def _save_ssh(self, dialog: SettingDialog) -> bool:
+        """Persist tool paths independently and retain a failed SSH draft on partial saves."""
+        widget = dialog.ssh_widget
+        configuration = widget.configuration()
+        try:
+            configuration.validate(optional=True)
+            if widget.request_id:
+                raise ValueError("Wait for SSH verification to finish before saving settings.")
+            if configuration.ssh_filename and widget.verified_configuration != configuration:
+                raise ValueError("Verify the SSH client before saving settings.")
+            self.preference.update({"ssh_filename": configuration.ssh_filename, "git_utility_dir": configuration.utility_dir})
+        except (OSError, TypeError, ValueError) as error:
+            widget.status_label.show_failure(str(error))
+            dialog.reveal_widget(SSH_PAGE_NAME, widget.status_label)
+            return False
+        widget.show_effective(*self._effective_ssh())
+        return True
+
+    def _effective_ssh(self) -> tuple[str, str]:
+        """Name the SSH client operations use now, and the source Settings shows for it: saved, detected or none."""
+        return self.ssh.configuration().ssh_filename, effective_source(self.ssh.saved_configuration(), self.ssh.detection())
+
+    def _verify_setting(self, git_filename: str) -> None:
+        """Check the Git path on an explicit Verify Git click, announcing a success so the click visibly did something."""
+        self._validate_setting(git_filename, False, announce=True)
+
+    def _validate_setting(self, git_filename: str, save: bool, announce: bool = False) -> None:
+        """Validate the current draft with a unique generation before any save; ``announce`` shows a success in green with a confirmation box."""
+        if self.session_registry_controller.setting_dialog is not None and self.session_registry_controller.setting_dialog.git_setting_widget.saving:
+            return
+        if save and self.session_registry_controller.setting_dialog is not None:
+            widget = self.session_registry_controller.setting_dialog.ssh_widget
+            if widget.request_id:
+                return
+            if widget.configuration().ssh_filename and widget.verified_configuration != widget.configuration():
+                self._verify_ssh(save=True)
+                return
+        self._invalidate_setting()
+        if self.startup_identity is not None:
+            self.validator.cancel(self.startup_identity.session_id)
+            self.startup_identity = None
+            self._abandon_waiting_openings()
+        if self.session_registry_controller.setting_dialog is None:
+            return
+        if save:
+            draft = self.session_registry_controller.setting_dialog.tool_draft()
+            try:
+                DifftoolRecipe(draft.difftool_filename, draft.difftool_command).validate(family=self.distribution_family, release=self.distribution_release)
+                MergetoolRecipe(draft.mergetool_filename, draft.mergetool_command).validate(optional=True, family=self.distribution_family, release=self.distribution_release)
+                draft.editor_recipe.validate()
+            except ValueError as error:
+                self.session_registry_controller.setting_dialog.status_label.show_failure(str(error))
+                return
+            if git_filename == self.preference.value_by_key["git_filename"]:
+                self._save_setting(git_filename, self.repository.git_version)
+                return
+        self.save_requested = save
+        self.setting_verify_clicked = announce
+        self.setting_identity = RequestIdentity(self.setting_session_id, self.setting_generation)
+        self.session_registry_controller.setting_dialog.set_loading(True)
+        self.validator.validate(git_filename, self.setting_identity, read_tools_folder=True)
+
+    def _invalidate_setting(self) -> None:
+        """Ensure an edited or closed draft cannot accept an older validation result."""
+        self.setting_generation += 1
+        self.setting_identity = None
+        self.save_requested = False
+        self.setting_verify_clicked = False
+        self.setting_validated_git_filename = ""
+        self.setting_tools_folder_warning = ""
+        self.validator.cancel(self.setting_session_id)
+
+    def _detect_setting(self) -> None:
+        """Put an explicitly detected candidate in the draft without changing active Git."""
+        candidate_filenames = detect_git_candidates()
+        if self.session_registry_controller.setting_dialog is None:
+            return
+        if not candidate_filenames:
+            self.session_registry_controller.setting_dialog.status_label.setText("Git was not found\nNo usable Git executable was found. Choose its path in Settings.")
+            return
+        first_candidate_index = 0
+        self.session_registry_controller.setting_dialog.path_edit.setText(candidate_filenames[first_candidate_index])
+        self._validate_setting(self.session_registry_controller.setting_dialog.typed_git_filename(), False)
+
+    def _close_setting(self) -> None:
+        """Abandon the draft and its validation without touching accepted preferences."""
+        self._invalidate_setting()
+        dialog = self.session_registry_controller.setting_dialog
+        if dialog is not None:
+            if dialog.ssh_widget.request_id:
+                self.repository.runner.cancel(dialog.ssh_widget.request_id)
+            dialog.account_page.abandon_sign_in()
+            dialog.git_setting_widget.stop_read()
+            dialog.deleteLater()
+        self.session_registry_controller.setting_dialog = None
+
+    def _restore_welcome_setting_label(self) -> None:
+        """Give every welcome window's settings button its usual label back once a validated Git is in use."""
+        for welcome in self.session_registry_controller.welcome_by_session.values():
+            welcome.setting_button.setText(SharedText.SETTING_BUTTON.value)
+
+    def initialize_git(self) -> None:
+        """Initialize the merge default and validate saved Git before considering detected choices.
+
+        Run once at launch, after the welcome window is shown. Without any Git to try, the welcome window learns it
+        through ``git_missing``; otherwise the answer comes back to ``git_validated``, which tries the next candidate.
+        """
+        self.preference.initialize_mergetool(save_detected=False)
+        saved_filename = str(self.preference.read("git_filename"))
+        self.candidate_filenames = [saved_filename] if saved_filename else detect_git_candidates()
+        if self.launch_validation_identity is not None:
+            self.validator.cancel(self.launch_validation_identity.session_id)
+            self.launch_validation_identity = None
+        self.startup_identity = RequestIdentity(uuid.uuid4().hex)
+        if not self.candidate_filenames:
+            self.startup_identity = None
+            self.git_missing.emit()
+            return
+        first_candidate_index = 0
+        candidate_filename = self.candidate_filenames.pop(first_candidate_index)
+        # Opening no longer asks Git for its version: an opening asked before this check answers waits for it, and
+        # resumes only with the Git the check accepted. The detected path is still shown right away in the settings.
+        self.repository.git_filename = candidate_filename
+        self.validator.validate(candidate_filename, self.startup_identity)
+
+    def forget_waiting_opening(self, session_id: str) -> None:
+        """Drop the opening a closed chooser was waiting to start, so the end of the startup check never starts it."""
+        self.waiting_opening_by_session.pop(session_id, None)
+
+    def git_validated(self, identity: RequestIdentity, git_filename: str, version: str, failure: RepositoryFailure | None) -> None:
+        """Publish the accepted executable only after the latest validation and successful sync."""
+        if identity == self.startup_identity:
+            if failure is not None and self.candidate_filenames:
+                first_candidate_index = 0
+                self.validator.validate(self.candidate_filenames.pop(first_candidate_index), identity)
+                return
+            self.startup_identity = None
+            if failure is not None:
+                self._abandon_waiting_openings()
+                self.git_missing.emit()
+                self._show_setting_failure(failure)
+                return
+            self.repository.git_filename = git_filename
+            self.repository.git_version = version
+            self._restore_welcome_setting_label()
+            self._resume_waiting_openings(git_filename)
+            return
+        if identity == self.launch_validation_identity:
+            self.launch_validation_identity = None
+            if failure is not None:
+                return
+            if self.repository.git_filename == git_filename or os.path.abspath(self.repository.git_filename) == git_filename:
+                self.repository.git_version = version
+            return
+        if identity != self.setting_identity or self.session_registry_controller.setting_dialog is None:
+            return
+        self.setting_identity = None
+        if failure is None:
+            self.setting_validated_git_filename = git_filename
+        self.session_registry_controller.setting_dialog.set_loading(False)
+        if failure is not None:
+            self._show_setting_failure(failure)
+            return
+        if self.setting_verify_clicked and not self.save_requested:
+            self.session_registry_controller.setting_dialog.show_git_verified(version, git_filename, self.setting_tools_folder_warning)
+        else:
+            self.session_registry_controller.setting_dialog.show_git_available(version, self.setting_tools_folder_warning)
+        widget = self.session_registry_controller.setting_dialog.git_setting_widget
+        if widget.git_filename != git_filename and not widget.dirty_target_set:
+            widget.stop_read()
+            widget.closed = False
+            widget.git_filename = git_filename
+            widget.reload()
+        if not self.save_requested:
+            return
+        self._save_setting(git_filename, version)
+
+    def git_tools_folder_checked(self, identity: RequestIdentity, _git_filename: str, warning: str) -> None:
+        """Keep the tools folder warning of the current Settings check until its validation is shown; the startup and launch checks never ask for one."""
+        if identity != self.setting_identity:
+            return
+        self.setting_tools_folder_warning = warning
+
+    def _save_setting(self, git_filename: str, version: str) -> None:
+        """Report preference and Git saves independently without losing either failed draft."""
+        if self.session_registry_controller.setting_dialog is None:
+            return
+        dialog = self.session_registry_controller.setting_dialog
+        generation = self.setting_generation
+        ssh_saved = self._save_ssh(dialog)
+        preference_saved = True
+        # The proof that this very save was validated exists only while it is being written. Its change signal arrives
+        # during the call and is the only one allowed to reuse it, which is what tells a real save apart from a change
+        # made elsewhere to the same path.
+        self.saving_validated_git_filename = git_filename if self.setting_validated_git_filename == git_filename else ""
+        draft = dialog.tool_draft()
+        try:
+            self.preference.update({"git_filename": git_filename, "difftool_filename": draft.difftool_filename, "difftool_command": draft.difftool_command,
+                                    MERGETOOL_FILENAME_PREFERENCE_KEY: draft.mergetool_filename, MERGETOOL_COMMAND_PREFERENCE_KEY: draft.mergetool_command,
+                                    **draft.editor_recipe.preference_value()})
+        except (OSError, TypeError, ValueError) as error:
+            self._show_setting_failure(RepositoryFailure("Save preferences", "", git_filename, [], str(error)))
+            preference_saved = False
+        finally:
+            self.saving_validated_git_filename = ""
+        if preference_saved:
+            self.repository.git_filename = git_filename
+            self.repository.git_version = version
+            self._restore_welcome_setting_label()
+            dialog.mergetool_save_notice_label.hide()
+        dialog.set_loading(True)
+
+        def complete(saved: bool) -> None:
+            """Close only after every requested domain succeeds in the original dialog.
+
+            This Save never writes account choices, so while Accounts still holds unsaved work the window stays open and
+            says where, instead of dropping that work by closing. The tools folder warning of the Git this Save checked
+            follows that line, since the window is still there to show it.
+            """
+            if self.session_registry_controller.setting_dialog is not dialog or not isValid(dialog):
+                return
+            dialog.set_loading(False)
+            if saved and preference_saved and ssh_saved and generation == self.setting_generation:
+                place_names = dialog.account_page.unsaved_place_names()
+                if place_names:
+                    dialog.mark_saved()
+                    dialog.show_success_with_warning("Settings saved. Unsaved changes remain in: " + ", ".join(place_names) + ".", self.setting_tools_folder_warning)
+                    return
+                dialog.accept()
+            elif not ssh_saved:
+                dialog.status_label.show_failure("Other application preferences saved. SSH settings need attention." if preference_saved else SETTING_FAILED_DRAFTS_TEXT)
+            elif not saved:
+                dialog.status_label.show_failure("Application preferences saved. Some Git settings need attention." if preference_saved else SETTING_FAILED_DRAFTS_TEXT)
+            elif not preference_saved:
+                # Git and SSH saved but the Tools preferences did not: without this branch the bottom line kept the
+                # "Verifying" wait text, and nothing said that the Tools drafts were not saved.
+                dialog.status_label.show_failure(SETTING_FAILED_DRAFTS_TEXT)
+
+        dialog.git_setting_widget.save(complete)
+
+    def _show_setting_failure(self, failure: RepositoryFailure) -> None:
+        """Present a sanitized cause and copyable details while preserving the Git draft."""
+        if self.session_registry_controller.setting_dialog is None:
+            return
+        diagnostic = Diagnostic(failure.operation, failure.repository_dir, failure.program_filename, failure.arguments,
+                                f"Cannot use {failure.program_filename}: {failure.cause}. Correct the path, then verify Git again.", failure.stderr, failure.return_code).prepare()
+        self.session_registry_controller.setting_dialog.show_failure(diagnostic)
+        if self.diagnostic_log is not None:
+            self.diagnostic_log.write(diagnostic)
+        dialog = ErrorDialog(diagnostic, self.session_registry_controller.setting_dialog)
+        self.session_registry_controller.dialogs.append(dialog)
+
+        def finish() -> None:
+            """Release the diagnostic and return focus to the editable Git path."""
+            if dialog in self.session_registry_controller.dialogs:
+                self.session_registry_controller.dialogs.remove(dialog)
+            if self.session_registry_controller.setting_dialog is not None:
+                self.session_registry_controller.setting_dialog.path_edit.setFocus()
+            dialog.deleteLater()
+
+        dialog.finished.connect(finish)
+        open_window_modal(dialog)
+
+    def preference_changed(self, changed_value_by_key: dict[str, object]) -> None:
+        """Apply successful shared changes to future reads and any currently open chooser.
+
+        A new Git or Git utilities folder also detects terminals again, since both decide where Git Bash is found.
+        """
+        if any(key in changed_value_by_key for key in ("git_filename", MERGETOOL_FILENAME_PREFERENCE_KEY, MERGETOOL_COMMAND_PREFERENCE_KEY)):
+            for session_id in tuple(self.session_registry_controller.session_by_id):
+                self.mergetool.invalidate_session(session_id)
+        if "git_filename" in changed_value_by_key:
+            self.repository.git_filename = str(changed_value_by_key["git_filename"])
+            self.repository.git_version = ""
+            self._abandon_waiting_openings()
+            if self.saving_validated_git_filename and self.saving_validated_git_filename == self.repository.git_filename:
+                # This very save was already validated, so checking it again would only repeat the same version probe,
+                # and an older check still running must not answer for it.
+                self.setting_validated_git_filename = ""
+                if self.launch_validation_identity is not None:
+                    self.validator.cancel(self.launch_validation_identity.session_id)
+                    self.launch_validation_identity = None
+            else:
+                self._validate_selected_git(self.repository.git_filename)
+        if "recent_dirs" in changed_value_by_key:
+            for window in self.session_registry_controller.welcome_by_session.values():
+                window.show_recent(changed_value_by_key["recent_dirs"])
+            for repository_window in self.session_registry_controller.window_by_session.values():
+                repository_window.show_recent_repositories(changed_value_by_key["recent_dirs"])
+        for session_id, window in self.session_registry_controller.window_by_session.items():
+            window.apply_reading_preference(changed_value_by_key)
+            window.apply_fetch_preference(changed_value_by_key)
+            if "diff_show_entire_file" in changed_value_by_key:
+                self.history_read_controller.change_diff_context(session_id, changed_value_by_key["diff_show_entire_file"])
+        for staging in self.staging_session_registry_controller.staging_by_key.values():
+            if "git_filename" in changed_value_by_key:
+                staging.set_git_filename(self.repository.git_filename)
+            if staging.window is not None and isValid(staging.window):
+                staging.window.apply_preference(changed_value_by_key)
+        # These two settings decide where Git Bash is searched; a terminal the user already chose is never replaced.
+        if "git_filename" in changed_value_by_key or "git_utility_dir" in changed_value_by_key:
+            self.terminal_registry.redetect()
+
+    def _resume_waiting_openings(self, accepted_git_filename: str) -> None:
+        """Release the openings asked during the startup check, but only those asked with the Git it accepted.
+
+        An opening whose window was closed or cancelled, or that was asked with another Git, is dropped. The others go
+        to ``waiting_opening_released``, whose receiver asks about their folder or starts their read.
+        """
+        waiting_openings = tuple(self.waiting_opening_by_session.items())
+        self.waiting_opening_by_session.clear()
+        for session_id, waiting in waiting_openings:
+            if self.session_registry_controller.identity_by_session.get(session_id) != waiting.identity or session_id not in self.session_registry_controller.welcome_by_session:
+                continue
+            if os.path.normcase(os.path.abspath(waiting.git_filename)) != os.path.normcase(os.path.abspath(accepted_git_filename)):
+                self._stop_waiting_opening(session_id, waiting, "Git changed while the repository was opening. Open it again.")
+                continue
+            self.waiting_opening_released.emit(waiting)
+
+    def _abandon_waiting_openings(self) -> None:
+        """Stop the openings waiting for a startup check that failed or was replaced, leaving their chooser usable."""
+        waiting_openings = tuple(self.waiting_opening_by_session.items())
+        self.waiting_opening_by_session.clear()
+        for session_id, waiting in waiting_openings:
+            self._stop_waiting_opening(session_id, waiting, "")
+
+    def _stop_waiting_opening(self, session_id: str, waiting: WaitingOpening, message: str) -> None:
+        """Give the chooser back to the user for one opening that will not start."""
+        if self.session_registry_controller.identity_by_session.get(session_id) != waiting.identity:
+            return
+        self.session_registry_controller.identity_by_session.pop(session_id, None)
+        welcome = self.session_registry_controller.welcome_by_session.get(session_id)
+        if welcome is None:
+            return
+        welcome.set_loading(False)
+        if message:
+            welcome.show_status(message)