gitpane 1.0.0__py3-none-any.whl

gitpane/ui/console/operation_dialog.py

@@ -0,0 +1,408 @@
+"""Present live filtered command output with supervised cancellation."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QSignalBlocker, QSize, Qt, Signal
+from PySide6.QtWidgets import QCheckBox, QDialog, QHBoxLayout, QLabel, QProgressBar, QPushButton, QScrollArea, QStyle, QVBoxLayout
+from shiboken6 import isValid
+
+from gitpane.config import (
+    CONSOLE_ABORTABLE_OPERATION_SET,
+    OPERATION_HEIGHT,
+    OPERATION_KEEP_OPEN_PREFERENCE_KEY,
+    OPERATION_WIDTH,
+    ConsoleOperation,
+    SharedText,
+    fit_window,
+)
+from gitpane.operation.console_line import COMPLETED_STATUS_SET
+from gitpane.operation.console_tone import ConsoleTone, result_tone
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.transport.refusal_notice import headline_first
+from gitpane.ui.console.operation_output_view import OperationOutputView
+from gitpane.ui.widget.result_label import ResultLabel
+from gitpane.ui.widget.standard_icon_label import StandardIconLabel
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QRect
+    from PySide6.QtGui import QCloseEvent, QShowEvent
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.operation.operation_trace import OperationTrace
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.process.process_runner import ProcessRequest
+
+# A pause names where the user picks the operation up again: the Rebase window for a rebase, the repository window
+# banner for a cherry-pick or revert, the conflicts for a Stash pop. The console kind decides it, since a Continue
+# started from the banner has no form.
+PAUSE_LABEL_BY_CONSOLE_OPERATION = {ConsoleOperation.REBASE: "Paused: Git is waiting for you in the Rebase window",
+                                    ConsoleOperation.REFERENCE: "Paused: resolve the commit operation before continuing",
+                                    ConsoleOperation.STASH_POP: "Paused: resolve the merge conflicts"}
+DEFAULT_PAUSE_LABEL = "Paused"
+# The red failure text repeats the server's lines and Git's last lines. Past this many lines it scrolls in its own
+# area, so the console keeps its size and the full output below keeps most of its height.
+FAILURE_TEXT_VISIBLE_LINE_COUNT = 10
+
+
+class OperationDialogText(Enum):
+    """Texts only the operation console shows, one member per text so a misspelt name is an error."""
+
+    COMPLETED = "Completed"
+    ABORTED = "Aborted"
+    PARTIALLY_COMPLETED = "Partially completed"
+
+
+# The status line for each end status but a pause, which shows where the user picks the operation up again. Every
+# status is written here one by one, so a status added later has no line until one is chosen for it: a cancelled run
+# reads like an Abort, a stop by a limit or a refusal like a failure, and an end GitPane did not observe as such
+# (a full queue, a volume refusal, a step that never began, a wait still under way…) as an unknown outcome.
+RESULT_TEXT_BY_STATUS: dict[OperationStatus, OperationDialogText | SharedText] = {
+    OperationStatus.SUCCESS: OperationDialogText.COMPLETED,
+    OperationStatus.ABORTED: OperationDialogText.ABORTED,
+    OperationStatus.CANCELLED: OperationDialogText.ABORTED,
+    OperationStatus.FAILED: SharedText.FAILED,
+    OperationStatus.REFUSED: SharedText.FAILED,
+    OperationStatus.START_FAILED: SharedText.FAILED,
+    OperationStatus.TIMEOUT: SharedText.FAILED,
+    OperationStatus.IDLE_TIMEOUT: SharedText.FAILED,
+    OperationStatus.PARTIAL: OperationDialogText.PARTIALLY_COMPLETED,
+    OperationStatus.UNKNOWN: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.VOLUME: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.QUEUE_FULL: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.NOT_STARTED: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.SIGN_IN_TIMEOUT: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.STEP_NOT_STARTED: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.NO_CHANGE: SharedText.OUTCOME_UNKNOWN,
+    OperationStatus.PENDING: SharedText.OUTCOME_UNKNOWN,
+}
+
+
+def status_line_text(status: OperationStatus, pause_label: str) -> str:
+    """Give the text of the console's status line for an end status; a pause shows where the user picks the operation up again."""
+    if status == OperationStatus.PAUSED:
+        return pause_label
+    # The fallback only keeps the console readable if a status is ever added without running the tests that require its line.
+    return RESULT_TEXT_BY_STATUS.get(status, SharedText.OUTCOME_UNKNOWN).value
+
+
+class OperationDialog(QDialog):
+    """Display safe operation records without taking ownership of the process."""
+
+    abort_requested = Signal()
+    followup_requested = Signal()
+
+    def __init__(self, trace: OperationTrace, title: str, parent: QWidget | None = None, keep_open: bool = True, *, preference: PreferenceStore | None = None,
+                 console_operation: ConsoleOperation) -> None:
+        """Build permanent controls beneath the scrolling plain-text output.
+
+        The console kind decides once whether Abort is offered, so callers never choose it one by one.
+        """
+        super().__init__(parent)
+        self.trace = trace
+        self.abortable = console_operation in CONSOLE_ABORTABLE_OPERATION_SET
+        self.pause_label = PAUSE_LABEL_BY_CONSOLE_OPERATION.get(console_operation, DEFAULT_PAUSE_LABEL)
+        self.running = True
+        self.success = False
+        self.completed = False
+        self.followup_pending = False
+        # Set by a result whose console carries a line the user must read: Keep dialog open changed in another console
+        # then leaves it open, and only the user's own click in this console closes it.
+        self.stays_open = False
+        self.preference = preference
+        self.dismissed = False
+        self.return_focus = parent.focusWidget() if parent else None
+        self.setWindowTitle(title)
+        self.resize(OPERATION_WIDTH, OPERATION_HEIGHT)
+        layout = QVBoxLayout(self)
+        status_row = QHBoxLayout()
+        icon_side = self.style().pixelMetric(QStyle.PixelMetric.PM_SmallIconSize)
+        self.status_icon = StandardIconLabel(QSize(icon_side, icon_side))
+        status_row.addWidget(self.status_icon, 0, Qt.AlignmentFlag.AlignVCenter)
+        self.status_label = QLabel("Starting…")
+        self.status_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.status_label.setWordWrap(True)
+        status_row.addWidget(self.status_label, 1)
+        layout.addLayout(status_row)
+        # Fetch and Push output is buried under the debug traces GitPane turns on, so a failure repeats here, in bold
+        # red, the plain reason and what Git itself said; the full output stays below. A long refusal (a hook's lines,
+        # repeated in Git's own lines) would make the console taller than the screen, so the reason scrolls in its own
+        # area and the console keeps its size.
+        self.failure_scroll_area = QScrollArea()
+        self.failure_scroll_area.setWidgetResizable(True)
+        self.failure_scroll_area.setFrameShape(QScrollArea.Shape.NoFrame)
+        # The text wraps, long words included, so a horizontal bar would never have anything to show.
+        self.failure_scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        # No extra Tab stop: the label keeps its own keyboard selection and the wheel still scrolls the area.
+        self.failure_scroll_area.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.failure_scroll_area.hide()
+        layout.addWidget(self.failure_scroll_area)
+        # The area is in the console before it takes the label, so the label watches the console for theme changes
+        # from the start: it follows its window every time its parent changes.
+        self.failure_label = ResultLabel()
+        self.failure_label.setAccessibleName("Failure reason")
+        self.failure_scroll_area.setWidget(self.failure_label)
+        self.failure_label.hide()
+        self.progress = QProgressBar()
+        self.progress.setRange(0, 0)
+        self.progress.setAccessibleName("Operation progress")
+        layout.addWidget(self.progress)
+        self.output_view = OperationOutputView(trace, self)
+        layout.addWidget(self.output_view, 1)
+        self.preference_label = QLabel()
+        self.preference_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.preference_label.setWordWrap(True)
+        self.preference_label.hide()
+        layout.addWidget(self.preference_label)
+        self.followup_label = QLabel()
+        self.followup_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.followup_label.setWordWrap(True)
+        self.followup_label.hide()
+        layout.addWidget(self.followup_label)
+        actions = QHBoxLayout()
+        self.keep_open_check = QCheckBox("Keep dialog open")
+        self.keep_open_check.setChecked(bool(preference.read(OPERATION_KEEP_OPEN_PREFERENCE_KEY)) if preference is not None else keep_open)
+        actions.addWidget(self.keep_open_check)
+        self.copy_button = QPushButton("Copy details")
+        self.copy_button.clicked.connect(self.output_view.copy_detail)
+        actions.addWidget(self.copy_button)
+        self.followup_button = QPushButton("Push tag")
+        self.followup_button.setAutoDefault(False)
+        self.followup_button.clicked.connect(self.followup_requested)
+        self.followup_button.hide()
+        actions.addWidget(self.followup_button)
+        self.abort_button = QPushButton("Abort")
+        self.abort_button.clicked.connect(self.request_abort)
+        # The button also gates Escape and the close button through request_abort, so a local console keeps it disabled as well as hidden.
+        self.abort_button.setEnabled(self.abortable)
+        self.abort_button.setVisible(self.abortable)
+        actions.addWidget(self.abort_button)
+        self.ok_button = QPushButton("OK")
+        self.ok_button.setEnabled(False)
+        self.ok_button.clicked.connect(self.accept)
+        actions.addWidget(self.ok_button)
+        layout.addLayout(actions)
+        self.keep_open_check.toggled.connect(self._keep_open)
+        trace.runner.stop_requested.connect(self._process_stopping)
+        if preference is not None:
+            preference.changed.connect(self._preference_changed)
+        self.finished.connect(self._restore_focus)
+        fit_window(self, 0, 0)
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Keep output, the red failure text and permanent actions reachable after screen or font changes."""
+        available = available_geometry if available_geometry is not None else self.screen().availableGeometry()
+        content_width = self._content_width(available)
+        self.output_view.refresh_metrics(content_width)
+        self._fit_failure_height(content_width)
+        self.layout().activate()
+        fit_window(self, 0, 0, available_geometry)
+
+    def _content_width(self, available: QRect) -> int:
+        """Return the width the console's content gets on a screen area: the console's width within that area, less the layout margins.
+
+        It is the only definition of that width, shared by the output view and the red failure text so both wrap alike.
+        """
+        margins = self.layout().contentsMargins()
+        return min(self.width(), available.width()) - margins.left() - margins.right()
+
+    def _fit_failure_height(self, width: int) -> None:
+        """Give the red failure area the height of its text wrapped at ``width``, at most ``FAILURE_TEXT_VISIBLE_LINE_COUNT`` lines; past that the text scrolls.
+
+        It runs when the text changes, when the console is shown and after a screen or font change, never on resize: a
+        console the user narrows shows the scroll bar a little earlier instead of measuring everything again at each step.
+        """
+        if self.failure_label.isHidden():
+            return
+        # The bold of the label's style sheet takes part in the measure.
+        self.failure_label.ensurePolished()
+        label_margins = self.failure_label.contentsMargins()
+        vertical_margin = label_margins.top() + label_margins.bottom() + self.failure_label.margin() * 2
+        height_limit = self.failure_label.fontMetrics().lineSpacing() * FAILURE_TEXT_VISIBLE_LINE_COUNT + vertical_margin
+        self.failure_scroll_area.setFixedHeight(min(self.failure_label.heightForWidth(width), height_limit))
+
+    def showEvent(self, event: QShowEvent) -> None:
+        """Refresh a reopened output view without retaining a second text document."""
+        self.dismissed = False
+        self.output_view.stopped = False
+        super().showEvent(event)
+        self.refresh_metrics()
+
+    def set_running(self) -> None:
+        """Show an active process while disabling premature dismissal; only a network console can be stopped."""
+        self.running = True
+        self.success = False
+        self.completed = False
+        self.output_view.output_highlighter.show_paused_result(False)
+        self.status_label.setText("Running…")
+        self.show_failure_text("")
+        self.abort_button.setEnabled(self.abortable)
+        self.ok_button.setEnabled(False)
+        self.progress.show()
+
+    def show_result(self, status: OperationStatus, complete: bool = True, *, failure_reported: bool = False, failure_text: str = "", failure_headline: str = "",
+                    expected_stop: bool = False, stays_open: bool = False) -> None:
+        """Keep every failure or incomplete trace available for inspection, and let an expected stop go like a success.
+
+        ``success`` means the operation reached its goal; ``completed`` also covers a verified Abort and an expected
+        stop, and decides whether Keep dialog open may dismiss the console. An expected stop is a pause that waits for
+        the user (a conflict or an edit stop of a rebase, a cherry-pick or revert conflict, or a Stash pop stopped on
+        conflicts when the caller says so with ``expected_stop``): like Git Extensions, the console then closes when
+        Keep dialog open is unchecked, since what the user must answer is elsewhere. ``failure_reported`` tells that the
+        result carries a failure cause: a pause with a cause (a refused hook, a fatal Git error) is a real failure and
+        keeps the console open, as does an incomplete trace. ``failure_text`` is a short explanation of a failure, shown
+        in bold red under the status line, after the ``failure_headline`` sentence when there is one; a success or an
+        expected stop never shows them. ``stays_open`` keeps a completed console open even with Keep dialog open
+        unchecked, for a success whose console carries a line the user must read (a pushed branch that could not be
+        linked to its remote branch); Keep dialog open takes over again as soon as the user changes it in this console,
+        while a change made from another console only updates its box. The byte counter is rewritten at once so the
+        result is shown with the exact total.
+        """
+        self.output_view.flush_output(exact_count=True)
+        complete = complete and self.trace.complete
+        # A plain pause waits for the user: Git's error lines explain the stop and are shown neutral. An incomplete trace
+        # or a reported failure keeps the error rendering and the console. The pause is read from the same classification
+        # as the colour of the console's end line, so the window and that line cannot disagree.
+        paused = result_tone(status, failure_reported=failure_reported or not complete, expected_stop=expected_stop) == ConsoleTone.PAUSED
+        neutral = paused or (status == OperationStatus.ABORTED and complete and not failure_reported)
+        failed = status != OperationStatus.SUCCESS and not paused
+        self.show_failure_text(failure_text if failed else "", failure_headline if failed else "")
+        self.running = False
+        self.stays_open = stays_open
+        self.success = status == OperationStatus.SUCCESS and complete
+        self.completed = (status in COMPLETED_STATUS_SET and complete) or neutral
+        self.output_view.output_highlighter.show_paused_result(paused)
+        label = self.pause_label if paused else status_line_text(status, self.pause_label)
+        self.status_label.setText(label if complete else "Trace incomplete: controlled exchanges are missing. Available command output is shown below.")
+        self.status_label.setWordWrap(True)
+        self.abort_button.setEnabled(False)
+        self.ok_button.setEnabled(True)
+        self.ok_button.setDefault(True)
+        self.ok_button.setFocus()
+        self.progress.hide()
+        if self.success:
+            icon = QStyle.StandardPixmap.SP_DialogApplyButton
+        elif neutral:
+            icon = QStyle.StandardPixmap.SP_MessageBoxInformation
+        else:
+            icon = QStyle.StandardPixmap.SP_MessageBoxWarning
+        self.status_icon.set_standard_pixmap(icon)
+        if self.completed and not stays_open and not self.followup_pending and not self.keep_open_check.isChecked() and not self.dismissed:
+            self.accept()
+
+    def show_failure_text(self, text: str, headline: str = "") -> None:
+        """Show a failure explanation in bold red under the status line, or hide the line when there is none.
+
+        It is also used to rewrite the explanation of a finished run, when something learned afterwards completes it,
+        such as an account found to need a reconnect. The text goes through the console's own filter once more, so nothing shown here can hold more than the output
+        does. The headline is GitPane's own sentence, built from an address and an account label that are not secrets:
+        it is shown first and unfiltered, because the filter has learned the Git username from the command's URL and
+        would hide the very account the sentence names. The explanation takes at most ``FAILURE_TEXT_VISIBLE_LINE_COUNT``
+        lines and scrolls past them, so the console keeps its size.
+        """
+        if not text and not headline:
+            self.failure_label.clear()
+            self.failure_label.hide()
+            self.failure_scroll_area.hide()
+            return
+        self.failure_label.show_failure(headline_first(headline, self.trace.filter.redact(text)))
+        self.failure_label.show()
+        self.failure_scroll_area.show()
+        self._fit_failure_height(self._content_width(self.screen().availableGeometry()))
+
+    def settle_pause(self) -> None:
+        """Treat a console that stopped on a failure as done once the user answered it or its operation ended.
+
+        An expected pause no longer waits here: its console is already completed when the result is shown. This covers
+        what stays open on a failure while the operation still waits for the user (a rebase step Git refused, a refused
+        push). From then on Keep dialog open decides, as for a completed result: the console closes now when the
+        option is unchecked, or later when the user unchecks it. A console that still runs is left alone, because
+        closing it would request a stop; nothing here aborts the operation.
+        """
+        if self.running or self.dismissed:
+            return
+        self.completed = True
+        if self.trace.complete and not self.followup_pending and not self.keep_open_check.isChecked():
+            self.accept()
+
+    def show_followup(self, message: str = "") -> None:
+        """Keep an explicitly requested follow-up available without changing the Git result."""
+        self.followup_pending = bool(message)
+        self.followup_label.setText(self.trace.filter.redact(message))
+        self.followup_label.setVisible(self.followup_pending)
+        self.followup_button.setVisible(self.followup_pending)
+
+    def _process_stopping(self, request: ProcessRequest, _cause: str) -> None:
+        """Display supervised timeout and shutdown while the process remains alive."""
+        if request.operation_id == self.trace.operation_id and self.running and not self.dismissed:
+            self.status_label.setText("Stopping…")
+            self.abort_button.setEnabled(False)
+
+    def request_abort(self) -> None:
+        """Request a supervised stop without claiming rollback or process exit."""
+        if self.running and self.abort_button.isEnabled():
+            self.status_label.setText("Stopping…")
+            self.abort_button.setEnabled(False)
+            self.abort_requested.emit()
+
+    def reject(self) -> None:
+        """Treat Escape and the window close action as stop while running."""
+        if self.running:
+            self.request_abort()
+            return
+        super().reject()
+
+    def accept(self) -> None:
+        """Prevent Enter or direct acceptance from dismissing a running operation."""
+        if not self.running:
+            super().accept()
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        """Keep the native dialog visible until a requested stop has actually completed."""
+        if self.running:
+            self.request_abort()
+            event.ignore()
+            return
+        super().closeEvent(event)
+
+    def _keep_open(self, checked: bool) -> None:
+        """Save the changed close preference, then close a finished console when the box was just unchecked.
+
+        A preference that cannot be saved puts the box back and says why, so the box never shows a choice that was lost.
+        Other open consoles follow the saved value through the preference store.
+        """
+        if self.preference is not None:
+            try:
+                self.preference.update({OPERATION_KEEP_OPEN_PREFERENCE_KEY: checked})
+            except (OSError, ValueError, TypeError) as error:
+                with QSignalBlocker(self.keep_open_check):
+                    self.keep_open_check.setChecked(not checked)
+                self.preference_label.setText("Could not save Keep dialog open: " + self.trace.filter.redact(str(error)))
+                self.preference_label.show()
+                return
+        self.preference_label.hide()
+        if self.completed and self.trace.complete and not self.followup_pending and not checked and not self.dismissed:
+            self.accept()
+
+    def _preference_changed(self, value_by_key: dict[str, object]) -> None:
+        """Share only successfully saved settings with other open operation dialogs.
+
+        A console held open for a line the user must read only follows the box: it closes on the user's own click in it,
+        never on a change made from another console.
+        """
+        if OPERATION_KEEP_OPEN_PREFERENCE_KEY not in value_by_key or self.dismissed:
+            return
+        checked = bool(value_by_key[OPERATION_KEEP_OPEN_PREFERENCE_KEY])
+        with QSignalBlocker(self.keep_open_check):
+            self.keep_open_check.setChecked(checked)
+        if self.completed and self.trace.complete and not self.followup_pending and not checked and not self.stays_open:
+            self.accept()
+
+    def _restore_focus(self) -> None:
+        """Restore focus only if the original trigger still exists, and stop the output rendering of the closed console."""
+        self.dismissed = True
+        self.output_view.stop()
+        if self.return_focus is not None and isValid(self.return_focus):
+            self.return_focus.setFocus()

gitpane/ui/console/operation_output.py

@@ -0,0 +1,91 @@
+"""Colour each console line from the tone the view stored on its block, without changing the filtered console text."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent
+from PySide6.QtGui import QColor, QFont, QSyntaxHighlighter, QTextCharFormat
+
+from gitpane.history.revision_file import utf16_length
+from gitpane.operation.console_tone import PAUSE_NEUTRAL_TONE_SET, ConsoleTone
+from gitpane.ui.look.theme_color import is_dark_palette
+from gitpane.ui.widget.result_label import ResultTone, result_color
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QObject
+    from PySide6.QtWidgets import QPlainTextEdit
+
+# The one place a console tone becomes a colour: green for a success, orange for what waits on the user or warns, red
+# for a failure. The colours themselves are the result colours of the rest of the application.
+RESULT_TONE_BY_CONSOLE_TONE = {
+    ConsoleTone.SUCCESS: ResultTone.SUCCESS,
+    ConsoleTone.PAUSED: ResultTone.WARNING,
+    ConsoleTone.CANCELLED: ResultTone.WARNING,
+    ConsoleTone.GIT_WARNING: ResultTone.WARNING,
+    ConsoleTone.FAILURE: ResultTone.FAILURE,
+    ConsoleTone.COMMAND_FAILURE: ResultTone.FAILURE,
+    ConsoleTone.GIT_ERROR: ResultTone.FAILURE,
+    ConsoleTone.FAILURE_CAUSE: ResultTone.FAILURE,
+}
+CONSOLE_TONE_VALUE_SET = frozenset(ConsoleTone)
+# Bold is kept for the cause GitPane writes to explain a refusal, so it stands out among Git's own red lines.
+BOLD_CONSOLE_TONE_SET = frozenset({ConsoleTone.FAILURE_CAUSE})
+
+
+class OperationOutputHighlighter(QSyntaxHighlighter):
+    """Colour a whole console line, in the current theme, from the tone stored as the state of its block.
+
+    The view sets that state from what the trace recorded for each line; this highlighter only reads it, so a colour
+    never depends on recognising a word in the text. Once the operation has stopped on an expected pause (a conflict
+    waiting for the user), Git's own error lines and the failure line of its command are left neutral: they describe
+    why Git stopped, not a failure. Errors GitPane reports itself keep their colour in every case. Only a cause GitPane
+    writes to explain a refusal is bold; every other line keeps the normal weight.
+    """
+
+    def __init__(self, output: QPlainTextEdit) -> None:
+        """Attach visual formatting to the existing bounded plain-text document."""
+        super().__init__(output.document())
+        self.output = output
+        self.paused_result = False
+        self.format_by_tone: dict[ConsoleTone, QTextCharFormat] = {}
+        self.refresh_palette()
+        output.installEventFilter(self)
+
+    def refresh_palette(self) -> None:
+        """Rebuild the colour of each tone for the console's actual background, then recolour the document."""
+        dark = is_dark_palette(self.output.palette())
+        format_by_tone: dict[ConsoleTone, QTextCharFormat] = {}
+        for tone, result_tone in RESULT_TONE_BY_CONSOLE_TONE.items():
+            text_format = QTextCharFormat()
+            text_format.setForeground(QColor(result_color(result_tone, dark)))
+            if tone in BOLD_CONSOLE_TONE_SET:
+                text_format.setFontWeight(QFont.Weight.Bold)
+            format_by_tone[tone] = text_format
+        self.format_by_tone = format_by_tone
+        self.rehighlight()
+
+    def show_paused_result(self, paused_result: bool) -> None:
+        """Switch between the pause rendering and the normal rendering, recoloring the whole document only on a change."""
+        if paused_result == self.paused_result:
+            return
+        self.paused_result = paused_result
+        self.rehighlight()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Recolor the document after a palette change while preserving selection and scroll."""
+        if event.type() == QEvent.Type.PaletteChange:
+            self.refresh_palette()
+        return super().eventFilter(watched, event)
+
+    def highlightBlock(self, text: str) -> None:
+        """Colour the whole line from its block's tone, in bold only for a cause GitPane wrote; a neutral or unknown state leaves it as it is."""
+        state = self.currentBlockState()
+        if state not in CONSOLE_TONE_VALUE_SET:
+            return
+        tone = ConsoleTone(state)
+        if tone == ConsoleTone.NEUTRAL:
+            return
+        if self.paused_result and tone in PAUSE_NEUTRAL_TONE_SET:
+            return
+        self.setFormat(0, utf16_length(text), self.format_by_tone[tone])