gitpane 1.0.0__py3-none-any.whl

gitpane/ui/look/application_style.py

@@ -0,0 +1,317 @@
+"""The style GitPane draws with: Fusion, whose dark theme greys are decided at the moment something is drawn."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QPointF, QSize, Qt
+from PySide6.QtGui import QColor, QIcon, QImage, QPainter, QPalette, QPen, QPixmap
+from PySide6.QtWidgets import QAbstractButton, QApplication, QComboBox, QFrame, QHeaderView, QProxyStyle, QScrollBar, QStyle, QStyleFactory, QStyleOptionFrame, QTabBar
+
+from gitpane.config import FUSION_STYLE_NAME, LEGACY_WINDOWS_STYLE_NAME, MACOS_PLATFORM_NAME, WINDOWS_PLATFORM_NAME
+from gitpane.ui.look.color_contrast import contrast_ratio, relative_luminance, shown_on_background
+from gitpane.ui.look.theme_color import is_dark_palette, theme_control_color, theme_line_color, toward_text
+from gitpane.ui.look.theme_palette import PALETTE_COLOR_GROUPS
+from gitpane.ui.look.warning_icon import readable_warning_icon
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from PySide6.QtWidgets import QStyleOption, QStyleOptionComplex, QWidget
+
+SEPARATOR_SHAPE_SET = {QFrame.Shape.HLine, QFrame.Shape.VLine}
+# The controls whose face Fusion paints with the palette's button color and that the user saw lighter on the dark
+# captures. A tab widget's pane, sliders and the empty bands of the commit box also read that color and are not listed:
+# they keep Fusion's look.
+CONTROL_CLASSES = (QAbstractButton, QComboBox, QTabBar, QHeaderView, QScrollBar)
+# Geometry of Fusion's own check box square and radio button circle, so the added contour lies exactly on Fusion's.
+# The square is drawn one pixel smaller than its rectangle, shifted half a pixel so its one-pixel lines fall on whole pixels.
+CHECK_BOX_CONTOUR_SHRINK = 1
+HALF_PIXEL = 0.5
+# The circle's center is one pixel right of and below the rectangle's center; its radius comes from the rectangle's
+# width made odd, halved, less one pixel.
+RADIO_CENTER_SHIFT = 1
+RADIO_WIDTH_PARITY = 2
+RADIO_RADIUS_DIVISOR = 2.0
+RADIO_RADIUS_INSET = 1
+# State a check box or radio button is in while it has the keyboard focus: Fusion frames it in the selection color then.
+KEYBOARD_FOCUS_STATE = QStyle.StateFlag.State_HasFocus | QStyle.StateFlag.State_KeyboardFocusChange
+
+# Contrast readability guidelines ask of a graphical element that is not text: an icon with no pixel reaching it is redrawn.
+MINIMUM_ICON_CONTRAST = 3.0
+# Contrast a disabled control's greyed text must keep against both the control grey and the line grey for the control to
+# get the lighter face: the face Fusion draws from the control grey it is given lies between these two greys. A
+# half-transparent greyed text, as macOS gives, lightens with the face and keeps its distance from it; an opaque grey, as
+# GTK themes give, is caught up by the face and almost vanishes, and so does an opaque grey about as dark as the control
+# grey, as KDE's Breeze gives. The recorded macOS dark palette gives 1.53 and the recorded Windows dark palette 1.50;
+# the recorded GTK dark themes give 1.16 to 1.22, and Breeze dark 1.04 against its control grey.
+DISABLED_TEXT_MINIMUM_CONTRAST = 1.35
+OPAQUE_ALPHA = 255
+# The text color is taken the whole way from the window color, as the text shows on the window, its transparency included.
+SHOWN_TEXT_RATIO = 1.0
+# Question and warning icons are made readable at the size a question shows them and at twice that size, for high-density screens,
+# when the system icon does not say which sizes it has.
+HIGH_DENSITY_ICON_SCALE = 2
+# Device pixel ratio an icon image is read at: the sizes asked for are already in device pixels, one per image pixel, so
+# Qt must not scale them again for the screen's density.
+UNSCALED_DEVICE_PIXEL_RATIO = 1.0
+
+
+class GitPaneFusionStyle(QProxyStyle):
+    """Workaround: Fusion with GitPane's dark-theme greys, decided each time something is drawn, never set in a palette.
+
+    Under macOS, setting any role of the application palette makes Qt drop the palettes macOS gives each kind of control,
+    which turns the text of buttons black in inactive windows. The dark greys are therefore never set in a palette: the
+    style decides them when it draws. In a dark palette:
+
+    - buttons, drop-down lists, tabs, column headers and scroll bars are drawn with a lighter control grey, laid on the
+      drawing's own option for that drawing only, so their text keeps the colors the system gives it; a disabled one
+      keeps Fusion's face when the system's greyed text would fade on the lighter one;
+    - check boxes and radio buttons get a contour in the theme's line grey, which Fusion would draw too dark to be seen
+      on a dark field, unless they have the keyboard focus, whose frame Fusion draws itself;
+    - a separator line (horizontal or vertical, sunken or plain) is one line of the line grey instead of Fusion's pair of
+      a near-white and a dark line.
+
+    The question icon of a dialog is also redrawn in the text color in a dark palette when none of its pixels stands out
+    from the window: macOS draws it in black at a low opacity, the same in both appearances. The warning icon is the icon
+    theme's symbolic shape painted in the warning color when the theme has no colored one, as GNOME's Adwaita.
+
+    A light palette is drawn by Fusion unchanged. The greys come from the application palette, not from the widget's
+    one: the palettes macOS gives column headers and lists carry an opaque white text that would give other greys.
+    """
+
+    def __init__(self) -> None:
+        """Wrap a fresh Fusion style and keep its name, which the rest of the application compares against."""
+        super().__init__(QStyleFactory.create(FUSION_STYLE_NAME))
+        self.setObjectName(self.baseStyle().objectName())
+
+    def drawPrimitive(self, element: QStyle.PrimitiveElement, option: QStyleOption, painter: QPainter, widget: QWidget | None = None) -> None:
+        """Draw a primitive as Fusion does, with the control grey on a dark control, then the contour of a check box or radio button."""
+        with lighter_control(option, widget):
+            super().drawPrimitive(element, option, painter, widget)
+        if not is_dark_palette(option.palette) or option.state & KEYBOARD_FOCUS_STATE == KEYBOARD_FOCUS_STATE:
+            return
+        if element == QStyle.PrimitiveElement.PE_IndicatorCheckBox:
+            draw_check_box_contour(option, painter)
+        elif element == QStyle.PrimitiveElement.PE_IndicatorRadioButton:
+            draw_radio_button_contour(option, painter)
+
+    def drawControl(self, element: QStyle.ControlElement, option: QStyleOption, painter: QPainter, widget: QWidget | None = None) -> None:
+        """Draw a separator as one grey line in a dark theme, and every other control as Fusion does, lighter when it is a dark control."""
+        if element == QStyle.ControlElement.CE_ShapedFrame and is_separator_option(option) and is_dark_palette(option.palette):
+            draw_separator_line(option, painter)
+            return
+        with lighter_control(option, widget):
+            super().drawControl(element, option, painter, widget)
+
+    def drawComplexControl(self, control: QStyle.ComplexControl, option: QStyleOptionComplex, painter: QPainter, widget: QWidget | None = None) -> None:
+        """Draw scroll bars, drop-down lists and tool buttons as Fusion does, with the control grey in a dark theme."""
+        with lighter_control(option, widget):
+            super().drawComplexControl(control, option, painter, widget)
+
+    def standardIcon(self, standard_icon: QStyle.StandardPixmap, option: QStyleOption | None = None, widget: QWidget | None = None) -> QIcon:
+        """Answer Fusion's icon, except the question and the warning icons, which are made readable on the palette they are shown on.
+
+        A question icon on a dark palette is redrawn in the text color when it is unreadable there; each size the icon has
+        is checked on its own, and an icon that already stands out from the window is kept as it is. A warning icon is the
+        icon theme's symbolic shape painted in the warning color when the theme has no colored warning icon, Fusion's
+        otherwise. The error and information icons stay Fusion's. The palette is the widget's when there is one, else the
+        application's.
+        """
+        icon = super().standardIcon(standard_icon, option, widget)
+        if standard_icon == QStyle.StandardPixmap.SP_MessageBoxWarning:
+            return readable_warning_icon(icon, self._icon_palette(widget), self._icon_sizes(icon, option, widget))
+        if standard_icon != QStyle.StandardPixmap.SP_MessageBoxQuestion:
+            return icon
+        palette = self._icon_palette(widget)
+        if not is_dark_palette(palette):
+            return icon
+        background = palette.color(QPalette.ColorRole.Window)
+        text_color = toward_text(palette, SHOWN_TEXT_RATIO)
+        readable_icon = QIcon()
+        for size in self._icon_sizes(icon, option, widget):
+            image = icon.pixmap(size, UNSCALED_DEVICE_PIXEL_RATIO).toImage()
+            readable_icon.addPixmap(QPixmap.fromImage(readable_icon_image(image, background, text_color)))
+        return readable_icon
+
+    def _icon_palette(self, widget: QWidget | None) -> QPalette:
+        """Return the palette an icon is shown on: the widget's when there is one, else the application's."""
+        return widget.palette() if widget is not None else QApplication.palette()
+
+    def _icon_sizes(self, icon: QIcon, option: QStyleOption | None, widget: QWidget | None) -> list[QSize]:
+        """Return the sizes an icon has, or the size a dialog shows it at and twice that for high-density screens when it does not say."""
+        sizes = icon.availableSizes()
+        if sizes:
+            return sizes
+        side = self.pixelMetric(QStyle.PixelMetric.PM_MessageBoxIconSize, option, widget)
+        return [QSize(side, side), QSize(side * HIGH_DENSITY_ICON_SCALE, side * HIGH_DENSITY_ICON_SCALE)]
+
+
+@contextmanager
+def lighter_control(option: QStyleOption, widget: QWidget | None) -> Iterator[None]:
+    """Lay the control grey on a dark control's option for one drawing, then give the option its own palette back.
+
+    The option Qt hands over is changed in place rather than copied: Python only knows the base type of some options,
+    such as the header option Qt builds for each column section, and a copy of that base type loses the fields Qt adds,
+    which Fusion would then read from memory nobody set. Any other widget, and any control in a light theme, is drawn
+    with its option untouched. A disabled control whose greyed text would fade on the lighter face gets the window color
+    instead: Fusion then draws a face just lighter than the window, on which that text keeps the color the system gives
+    it and still reads. The GTK themes give their disabled controls the window color already, so their look does not
+    change; KDE's Breeze gives them a lighter grey, on which its dark greyed text would almost vanish once Fusion lightens it.
+    """
+    if not isinstance(widget, CONTROL_CLASSES) or not is_dark_palette(option.palette):
+        yield
+        return
+    application_palette = QApplication.palette()
+    face_color = theme_control_color(application_palette)
+    if not option.state & QStyle.StateFlag.State_Enabled and disabled_text_fades_on_lighter_face(application_palette):
+        face_color = application_palette.color(QPalette.ColorGroup.Active, QPalette.ColorRole.Window)
+    original_palette = QPalette(option.palette)
+    palette = QPalette(original_palette)
+    for group in PALETTE_COLOR_GROUPS:
+        palette.setColor(group, QPalette.ColorRole.Button, face_color)
+    option.palette = palette
+    try:
+        yield
+    finally:
+        option.palette = original_palette
+
+
+def disabled_text_fades_on_lighter_face(palette: QPalette) -> bool:
+    """Tell whether a disabled control's greyed text would fade on the lighter control face of a dark theme.
+
+    The face Fusion draws lies between the control grey and the line grey. The text is composed on each of them,
+    transparency included, and compared with it; the lower contrast decides, so that a greyed text lighter than the
+    face (GTK themes) and one about as dark as the control grey (Breeze) are both caught. The decision reads the palette
+    only, so it is the same for every control of a theme and never depends on which system draws it.
+
+    The palette given is the application palette, and the decision reads its disabled ``ButtonText``, while Fusion draws
+    the text with the class palette of the control. It therefore assumes that the control classes the style lightens
+    (buttons, combo boxes, tabs, headers, scroll bars) have the same disabled text as the application. That holds on
+    every recorded palette, macOS, Windows, Nordic, Yaru-dark, Adwaita and Breeze: macOS gives menus another disabled
+    text, but menus are not lightened.
+    """
+    text = palette.color(QPalette.ColorGroup.Disabled, QPalette.ColorRole.ButtonText)
+    for face in (theme_control_color(palette), theme_line_color(palette)):
+        if contrast_ratio(shown_on_background(text, face), face) < DISABLED_TEXT_MINIMUM_CONTRAST:
+            return True
+    return False
+
+
+def is_separator_option(option: QStyleOption) -> bool:
+    """Tell whether a frame being drawn is a horizontal or vertical separator line rather than a box."""
+    return isinstance(option, QStyleOptionFrame) and option.frameShape in SEPARATOR_SHAPE_SET
+
+
+def contour_pen() -> QPen:
+    """Answer the pen of a contour: the theme's line grey of the application palette, one pixel wide."""
+    return QPen(theme_line_color(QApplication.palette()))
+
+
+def draw_check_box_contour(option: QStyleOption, painter: QPainter) -> None:
+    """Draw a one-pixel square in the line grey over the border Fusion just gave a check box, leaving its inside as it is."""
+    painter.save()
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+    painter.translate(HALF_PIXEL, HALF_PIXEL)
+    painter.setPen(contour_pen())
+    painter.setBrush(Qt.BrushStyle.NoBrush)
+    painter.drawRect(option.rect.adjusted(0, 0, -CHECK_BOX_CONTOUR_SHRINK, -CHECK_BOX_CONTOUR_SHRINK))
+    painter.restore()
+
+
+def draw_radio_button_contour(option: QStyleOption, painter: QPainter) -> None:
+    """Draw a one-pixel circle in the line grey over the outline Fusion just gave a radio button, leaving its inside as it is."""
+    rect = option.rect
+    center = QPointF(rect.center()) + QPointF(RADIO_CENTER_SHIFT, RADIO_CENTER_SHIFT)
+    radius = (rect.width() + (rect.width() + 1) % RADIO_WIDTH_PARITY) / RADIO_RADIUS_DIVISOR - RADIO_RADIUS_INSET
+    painter.save()
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+    painter.setPen(contour_pen())
+    painter.setBrush(Qt.BrushStyle.NoBrush)
+    painter.drawEllipse(center, radius, radius)
+    painter.restore()
+
+
+def draw_separator_line(option: QStyleOptionFrame, painter: QPainter) -> None:
+    """Draw a separator as a single one-pixel line through the middle of its rectangle, in the theme's line grey.
+
+    The grey comes from the application palette, the same for every window, so a separator matches the other lines.
+    An empty rectangle draws nothing.
+    """
+    rect = option.rect
+    if rect.isEmpty():
+        return
+    painter.save()
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing, False)
+    painter.setPen(QPen(theme_line_color(QApplication.palette())))
+    if option.frameShape == QFrame.Shape.HLine:
+        painter.drawLine(rect.left(), rect.center().y(), rect.right(), rect.center().y())
+    else:
+        painter.drawLine(rect.center().x(), rect.top(), rect.center().x(), rect.bottom())
+    painter.restore()
+
+
+def readable_icon_image(image: QImage, background: QColor, text_color: QColor) -> QImage:
+    """Return an icon image that stands out from the background it is shown on.
+
+    macOS draws its question icon as a black glyph at a low opacity, the same in both appearances, almost invisible on a
+    dark window. When no pixel of the image reaches the contrast asked of an icon on that background, the pixels darker
+    than the background are redrawn in the text color, their opacity raised so the strongest becomes opaque; the other
+    pixels, such as highlights, are kept. An image that already stands out comes back as a copy, unchanged.
+    """
+    source = image.convertToFormat(QImage.Format.Format_ARGB32)
+    background_luminance = relative_luminance(background)
+    strongest_dark_alpha = 0
+    for y in range(source.height()):
+        for x in range(source.width()):
+            color = source.pixelColor(x, y)
+            if not color.alpha():
+                continue
+            if contrast_ratio(shown_on_background(color, background), background) >= MINIMUM_ICON_CONTRAST:
+                return QImage(image)
+            if relative_luminance(color) < background_luminance:
+                strongest_dark_alpha = max(strongest_dark_alpha, color.alpha())
+    if not strongest_dark_alpha:
+        return QImage(image)
+    readable = QImage(source)
+    for y in range(source.height()):
+        for x in range(source.width()):
+            color = source.pixelColor(x, y)
+            if not color.alpha() or relative_luminance(color) >= background_luminance:
+                continue
+            redrawn = QColor(text_color)
+            redrawn.setAlphaF(text_color.alphaF() * min(OPAQUE_ALPHA, color.alpha() * OPAQUE_ALPHA / strongest_dark_alpha) / OPAQUE_ALPHA)
+            readable.setPixelColor(x, y, redrawn)
+    readable.setDevicePixelRatio(image.devicePixelRatio())
+    return readable
+
+
+def system_style_name(platform_name: str, current_style_name: str) -> str:
+    """Name the style GitPane puts in place of Qt's default on a Qt platform, or "" to keep the default.
+
+    Fusion gives the same control sizes and the same form layout on every system, whereas Qt's own macOS style makes a
+    button taller than the field beside it and centres forms. On Windows only the legacy default style is replaced: it
+    forces light colours whatever the system palette, while Fusion follows it and keeps selected controls readable.
+    """
+    if platform_name == MACOS_PLATFORM_NAME:
+        return FUSION_STYLE_NAME
+    if platform_name == WINDOWS_PLATFORM_NAME and current_style_name.casefold() == LEGACY_WINDOWS_STYLE_NAME:
+        return FUSION_STYLE_NAME
+    return ""
+
+
+def configure_system_style(application: QApplication, platform_name: str = "") -> None:
+    """Put the style GitPane runs on in place of Qt's default, at start-up and in the test session.
+
+    Whenever that style is Fusion, it is GitPane's Fusion, which adds the greys of a dark theme: on macOS, on Windows in
+    place of the legacy style, and offscreen or on Linux where Qt already starts with Fusion. A style that is not Fusion
+    is left as it is. The platform name comes from Qt unless given; tests give it to check every platform from any
+    system. A second call changes nothing.
+    """
+    current_style = application.style()
+    current_style_name = current_style.objectName()
+    style_name = system_style_name(platform_name or application.platformName(), current_style_name) or current_style_name
+    if style_name.casefold() != FUSION_STYLE_NAME.casefold() or isinstance(current_style, GitPaneFusionStyle):
+        return
+    application.setStyle(GitPaneFusionStyle())

gitpane/ui/look/avatar_label.py

@@ -0,0 +1,53 @@
+"""Render large fallback initials without letting font margins enlarge the author avatar."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+from PySide6.QtGui import QFontMetricsF, QPainter, QPalette
+from PySide6.QtWidgets import QLabel
+
+from gitpane.config import AVATAR_INITIALS_FILL_RATIO
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QPaintEvent
+
+
+class AvatarLabel(QLabel):
+    """Keep native photo display while fitting fallback glyphs inside a centered square."""
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Size initials by their visible strokes so accents and wide letters remain unclipped."""
+        text = self.text()
+        if not text or not self.pixmap().isNull():
+            super().paintEvent(event)
+            return
+        rectangle = self.contentsRect()
+        font = self.font()
+        font.setWeight(font.Weight.DemiBold)
+        reference_size = max(1, min(rectangle.width(), rectangle.height()))
+        font.setPixelSize(reference_size)
+        bounds = QFontMetricsF(font, self).tightBoundingRect(text)
+        if bounds.isEmpty():
+            return
+        target_width = rectangle.width() * AVATAR_INITIALS_FILL_RATIO
+        target_height = rectangle.height() * AVATAR_INITIALS_FILL_RATIO
+        lower_size = 1
+        upper_size = max(1, math.ceil(reference_size * max(target_width / bounds.width(), target_height / bounds.height())))
+        fitted_size = lower_size
+        while lower_size <= upper_size:
+            candidate_size = (lower_size + upper_size) // 2
+            font.setPixelSize(candidate_size)
+            bounds = QFontMetricsF(font, self).tightBoundingRect(text)
+            if bounds.width() <= target_width and bounds.height() <= target_height:
+                fitted_size = candidate_size
+                lower_size = candidate_size + 1
+            else:
+                upper_size = candidate_size - 1
+        font.setPixelSize(fitted_size)
+        bounds = QFontMetricsF(font, self).tightBoundingRect(text)
+        painter = QPainter(self)
+        painter.setFont(font)
+        painter.setPen(self.palette().color(QPalette.ColorRole.WindowText))
+        painter.drawText(rectangle.toRectF().center() - bounds.center(), text)

gitpane/ui/look/color_contrast.py

@@ -0,0 +1,43 @@
+"""Measure how far apart two colours look, the way readability guidelines compute it."""
+
+from __future__ import annotations
+
+from PySide6.QtGui import QColor
+
+# Relative luminance of a color as readability guidelines define it: each sRGB channel is made linear (a straight
+# division below a small threshold, a power curve above it), then the channels are weighted by how bright the eye sees them.
+SRGB_LINEAR_THRESHOLD = 0.03928
+SRGB_LINEAR_DIVISOR = 12.92
+SRGB_CURVE_OFFSET = 0.055
+SRGB_CURVE_SCALE = 1.055
+SRGB_CURVE_EXPONENT = 2.4
+RED_LUMINANCE_WEIGHT = 0.2126
+GREEN_LUMINANCE_WEIGHT = 0.7152
+BLUE_LUMINANCE_WEIGHT = 0.0722
+# Light added to both luminances of a contrast ratio, for the glare of a real screen; it keeps black on black at 1:1.
+CONTRAST_FLARE = 0.05
+
+
+def relative_luminance(color: QColor) -> float:
+    """Return how bright a color looks, from 0 for black to 1 for white, the way readability guidelines measure it."""
+    channels: list[float] = []
+    for value in (color.redF(), color.greenF(), color.blueF()):
+        if value <= SRGB_LINEAR_THRESHOLD:
+            channels.append(value / SRGB_LINEAR_DIVISOR)
+        else:
+            channels.append(((value + SRGB_CURVE_OFFSET) / SRGB_CURVE_SCALE) ** SRGB_CURVE_EXPONENT)
+    red, green, blue = channels
+    return RED_LUMINANCE_WEIGHT * red + GREEN_LUMINANCE_WEIGHT * green + BLUE_LUMINANCE_WEIGHT * blue
+
+
+def contrast_ratio(first: QColor, second: QColor) -> float:
+    """Compare two colors the way readability guidelines do: 1 for identical colors, 21 for black on white."""
+    lighter, darker = sorted((relative_luminance(first), relative_luminance(second)), reverse=True)
+    return (lighter + CONTRAST_FLARE) / (darker + CONTRAST_FLARE)
+
+
+def shown_on_background(color: QColor, background: QColor) -> QColor:
+    """Return the opaque color a possibly transparent pixel shows once drawn on an opaque background."""
+    alpha = color.alphaF()
+    return QColor.fromRgbF(color.redF() * alpha + background.redF() * (1 - alpha), color.greenF() * alpha + background.greenF() * (1 - alpha),
+                           color.blueF() * alpha + background.blueF() * (1 - alpha))

gitpane/ui/look/desktop_appearance_follower.py

@@ -0,0 +1,118 @@
+"""Keep the palette of Qt's GTK 3 theme on the light or dark appearance the desktop portal declares.
+
+Under GNOME, Settings > Appearance only changes the portal's ``color-scheme`` preference; GTK 3 does not follow it, and
+Qt's GTK theme takes its palette from GTK, so GitPane's windows kept their light content under a dark title bar. The
+follower reads the preference once before the first window, then follows each change, and passes it on to GTK for
+this process through ``GtkSettingsLibrary``. The windows then follow the new palette through the application's usual
+palette followers, like on any desktop whose theme changes.
+
+When the portal declares no preference (GNOME's "Default", a portal missing or too slow at start), GTK keeps the dark
+preference it read from its own configuration: nothing is changed at start, and a later change to no preference gives
+GTK back the value it had before GitPane changed it.
+
+A GTK theme without a dark variant stays light: GitPane then shows what GTK can do, like a GTK 3 application. With
+``GTK_THEME`` set, the user picked the theme and its variant for the process, and GTK ignores the preference: nothing
+is followed then.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Qt, Slot
+from PySide6.QtDBus import QDBusConnection
+from PySide6.QtGui import QGuiApplication
+
+from gitpane.config import PORTAL_SETTING_READ_TIMEOUT_MS, WAYLAND_PLATFORM_NAME, X11_PLATFORM_NAME
+from gitpane.system.appearance_portal import PortalColorScheme, PortalColorSchemeWatcher, read_portal_color_scheme
+from gitpane.system.xdg_session import desktop_names
+from gitpane.ui.look.gtk_settings import GtkSettingsLibrary
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+    from PySide6.QtWidgets import QApplication
+
+GTK_THEME_ENVIRONMENT_NAME = "GTK_THEME"
+# The Qt platforms on which Qt's GTK 3 theme can be the platform theme.
+GTK_THEME_PLATFORM_NAME_SET = frozenset({WAYLAND_PLATFORM_NAME, X11_PLATFORM_NAME})
+# The desktops, as lowercased XDG_CURRENT_DESKTOP names, on which passing the portal's preference to GTK was checked to
+# give the theme's own dark palette. Another desktop keeps Qt's own behaviour until it is checked the same way.
+PORTAL_APPEARANCE_DESKTOP_SET = frozenset({"gnome"})
+
+
+def follows_portal_appearance(platform_name: str, environment_by_name: Mapping[str, str]) -> bool:
+    """Tell whether GitPane passes the portal's light or dark preference on to GTK in this session.
+
+    Only on a Qt platform that can load Qt's GTK 3 theme, on a desktop where the manoeuvre was checked, and when
+    ``GTK_THEME`` does not pin the GTK theme and its variant.
+    """
+    if platform_name not in GTK_THEME_PLATFORM_NAME_SET:
+        return False
+    if environment_by_name.get(GTK_THEME_ENVIRONMENT_NAME, ""):
+        return False
+    for name in desktop_names(environment_by_name):
+        if name in PORTAL_APPEARANCE_DESKTOP_SET:
+            return True
+    return False
+
+
+class DesktopAppearanceFollower(QObject):
+    """Pass each preference the portal declares on to GTK, then make Qt's GTK theme read GTK's colours again."""
+
+    def __init__(self, gtk_settings: GtkSettingsLibrary, watcher: PortalColorSchemeWatcher, parent: QObject | None = None) -> None:
+        """Keep the GTK settings and own the watcher, whose changes are applied inside its own signal."""
+        super().__init__(parent)
+        self.gtk_settings = gtk_settings
+        # Read before any change, so this is the dark preference GTK took from its own configuration: the one a later
+        # "no preference" of the portal gives back.
+        self.gtk_prefers_dark = gtk_settings.prefers_dark()
+        self.watcher = watcher
+        watcher.setParent(self)
+        watcher.changed.connect(self.apply, Qt.ConnectionType.DirectConnection)
+
+    @Slot(object)
+    def apply(self, scheme: PortalColorScheme) -> None:
+        """Ask GTK for the variant ``scheme`` names, then set its theme name again so Qt rebuilds its palette from it.
+
+        No preference names GTK's own dark preference, read when the follower was made.
+
+        Workaround, tied to two details of Qt 6.11: Qt's GTK theme rebuilds its palette only when GTK's theme name
+        changes, and QtDBus delivers the portal's change to GitPane's subscription, made after Qt's own, before Qt's
+        listeners. Applied at once, inside the D-Bus delivery and without a timer, GTK already has the new colours when
+        Qt's listeners react. Deferred, Qt first rebuilds its palette with GTK's old colours, after which the theme
+        name set again no longer rebuilds it, and the window keeps the preference of one appearance with the palette of
+        the other.
+        """
+        prefers_dark = self.gtk_prefers_dark if scheme == PortalColorScheme.NO_PREFERENCE else scheme.prefers_dark
+        self.gtk_settings.set_prefers_dark(prefers_dark)
+        self.gtk_settings.reload_theme()
+
+
+def install_desktop_appearance_follower(application: QApplication, platform_name: str = "", environment_by_name: Mapping[str, str] = os.environ,
+                                        connect: Callable[[], QDBusConnection] = QDBusConnection.sessionBus,
+                                        load_gtk_settings: Callable[[], GtkSettingsLibrary | None] = GtkSettingsLibrary.loaded) -> DesktopAppearanceFollower | None:
+    """Pass the portal's preference on to GTK before the first window, and keep doing it at each change, when this session needs it.
+
+    Called once the application exists, so GTK is loaded and Qt's own portal listeners are subscribed before
+    GitPane's. Answers nothing, without reading or loading anything, when the session does not follow the portal this
+    way or when GTK is not in the process. ``platform_name`` is the Qt platform, read from the application when not
+    given; ``connect`` opens the bus the portal is on and ``load_gtk_settings`` finds GTK's settings: tests give a
+    private bus and a stand-in for GTK. Calling it again answers the follower already installed. A portal that gives no
+    preference at start, or does not answer, changes nothing in GTK.
+    """
+    if not follows_portal_appearance(platform_name or QGuiApplication.platformName(), environment_by_name):
+        return None
+    for child in application.children():
+        if isinstance(child, DesktopAppearanceFollower):
+            return child
+    gtk_settings = load_gtk_settings()
+    if gtk_settings is None:
+        return None
+    connection = connect()
+    follower = DesktopAppearanceFollower(gtk_settings, PortalColorSchemeWatcher(lambda: connection), application)
+    scheme = read_portal_color_scheme(connection, PORTAL_SETTING_READ_TIMEOUT_MS)
+    if scheme != PortalColorScheme.NO_PREFERENCE:
+        follower.apply(scheme)
+    return follower

gitpane/ui/look/fixed_font.py

@@ -0,0 +1,21 @@
+"""Give monospace text the size of the application's body text."""
+
+from __future__ import annotations
+
+from PySide6.QtGui import QFont, QFontDatabase
+from PySide6.QtWidgets import QApplication
+
+
+def body_sized_fixed_font() -> QFont:
+    """Return the system's monospace font at the size of the application font, so an output or a hash reads like the text around it.
+
+    The system's monospace font has a size of its own, often smaller than the body text. An application font set in
+    pixels has no point size (Qt answers -1 and ignores that value), so its pixel size is given instead.
+    """
+    body_font = QApplication.font()
+    fixed_font = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+    if body_font.pointSizeF() > 0:
+        fixed_font.setPointSizeF(body_font.pointSizeF())
+    else:
+        fixed_font.setPixelSize(body_font.pixelSize())
+    return fixed_font