gitpane 1.0.0__py3-none-any.whl

gitpane/ui/look/gtk_settings.py

@@ -0,0 +1,116 @@
+"""Change GTK 3's own settings inside this process through the GTK library that Qt's GTK theme already loaded.
+
+Workaround for Qt 6.11's GTK 3 platform theme under a desktop that switches between light and dark through the
+freedesktop Settings portal, as GNOME does. GTK 3 does not follow the portal's ``color-scheme`` preference: with the
+desktop's ``Adwaita`` theme it stays light. Qt reads the preference from the portal itself but takes its palette from
+GTK, so a dark desktop gives Qt windows a dark title bar on a light content. Qt also rebuilds that palette only when
+GTK's ``gtk-theme-name`` changes. GitPane therefore sets GTK's own dark preference (``gtk-application-prefer-dark-theme``)
+for this process alone, then sets the theme name again to its own value, which makes Qt read GTK's colours again.
+Nothing is written outside the process: no desktop setting, no settings file.
+
+The library is only reached when Qt already loaded it (``RTLD_NOLOAD``): GitPane never loads GTK itself, and on a
+system or a Qt platform where GTK is not in the process there is nothing to change.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+
+GTK_LIBRARY_NAME = "libgtk-3.so.0"
+GOBJECT_LIBRARY_NAME = "libgobject-2.0.so.0"
+# g_free, which releases the text g_object_get hands over, lives in GLib.
+GLIB_LIBRARY_NAME = "libglib-2.0.so.0"
+PREFER_DARK_PROPERTY = b"gtk-application-prefer-dark-theme"
+THEME_NAME_PROPERTY = b"gtk-theme-name"
+# The name of the dlopen flag that only answers a library already loaded; Windows has no such flag.
+NO_LOAD_FLAG_NAME = "RTLD_NOLOAD"
+# g_object_set and g_object_get read property name and value pairs until a null name.
+PROPERTY_LIST_END = None
+
+
+def already_loaded_library(name: str) -> ctypes.CDLL | None:
+    """Answer the library ``name`` when this process already loaded it, without ever loading it, or nothing."""
+    no_load_flag = getattr(os, NO_LOAD_FLAG_NAME, None)
+    if no_load_flag is None:
+        return None
+    try:
+        return ctypes.CDLL(name, mode=no_load_flag | os.RTLD_LAZY)
+    except OSError:
+        return None
+
+
+class GtkSettingsLibrary:
+    """The default GTK settings object of this process, with the two changes that make Qt's GTK theme follow a dark preference.
+
+    g_object_set and g_object_get take a variable list of arguments. Each one is given a fixed signature for the one
+    shape GitPane passes: only pointers and whole numbers travel, which the x86-64 and ARM 64-bit Linux calling
+    conventions pass the same way for a variable list and a fixed one.
+    """
+
+    def __init__(self, gtk: ctypes.CDLL, gobject: ctypes.CDLL, glib: ctypes.CDLL, settings: int) -> None:
+        """Keep the libraries and the settings object, and declare once the C signature of every function called."""
+        self.settings = ctypes.c_void_p(settings)
+        self.set_number_property = gobject["g_object_set"]
+        self.set_number_property.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int, ctypes.c_void_p]
+        self.set_number_property.restype = None
+        self.set_text_property = gobject["g_object_set"]
+        self.set_text_property.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_void_p]
+        self.set_text_property.restype = None
+        self.get_text_property = gobject["g_object_get"]
+        self.get_text_property.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p), ctypes.c_void_p]
+        self.get_text_property.restype = None
+        self.get_number_property = gobject["g_object_get"]
+        self.get_number_property.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_int), ctypes.c_void_p]
+        self.get_number_property.restype = None
+        self.free = glib["g_free"]
+        self.free.argtypes = [ctypes.c_void_p]
+        self.free.restype = None
+        # The libraries stay referenced for as long as their functions may be called.
+        self.libraries = (gtk, gobject, glib)
+
+    @classmethod
+    def loaded(cls) -> GtkSettingsLibrary | None:
+        """Answer the GTK settings of this process when Qt's GTK theme loaded and started GTK, otherwise nothing.
+
+        Nothing is loaded: the libraries are only looked up among those already in the process. GTK loaded but not
+        started yet has no default settings object, and nothing is answered either.
+        """
+        gtk = already_loaded_library(GTK_LIBRARY_NAME)
+        gobject = already_loaded_library(GOBJECT_LIBRARY_NAME)
+        glib = already_loaded_library(GLIB_LIBRARY_NAME)
+        if gtk is None or gobject is None or glib is None:
+            return None
+        get_default_settings = gtk["gtk_settings_get_default"]
+        get_default_settings.argtypes = []
+        get_default_settings.restype = ctypes.c_void_p
+        settings = get_default_settings()
+        if not settings:
+            return None
+        return cls(gtk, gobject, glib, settings)
+
+    def prefers_dark(self) -> bool:
+        """Tell whether GTK asks for the dark variant of its theme in this process.
+
+        Before GitPane changes anything, this is the value GTK read from its own configuration (``settings.ini``,
+        ``gtk-application-prefer-dark-theme``); afterwards, the last value this process set.
+        """
+        prefers_dark = ctypes.c_int(0)
+        self.get_number_property(self.settings, PREFER_DARK_PROPERTY, ctypes.byref(prefers_dark), PROPERTY_LIST_END)
+        return bool(prefers_dark.value)
+
+    def set_prefers_dark(self, prefers_dark: bool) -> None:
+        """Ask GTK for the dark variant of its theme in this process, or for the light one; Qt does not see it until ``reload_theme``."""
+        self.set_number_property(self.settings, PREFER_DARK_PROPERTY, int(prefers_dark), PROPERTY_LIST_END)
+
+    def reload_theme(self) -> None:
+        """Set GTK's theme name again to its own value: the one notice on which Qt's GTK theme reads GTK's colours again."""
+        theme_name_pointer = ctypes.c_void_p()
+        self.get_text_property(self.settings, THEME_NAME_PROPERTY, ctypes.byref(theme_name_pointer), PROPERTY_LIST_END)
+        if not theme_name_pointer.value:
+            return
+        try:
+            theme_name = ctypes.string_at(theme_name_pointer.value)
+            self.set_text_property(self.settings, THEME_NAME_PROPERTY, theme_name, PROPERTY_LIST_END)
+        finally:
+            self.free(theme_name_pointer)

gitpane/ui/look/icon_density.py

@@ -0,0 +1,16 @@
+"""Turn a logical icon side into the device pixels Qt asks for at a screen density."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QSize
+
+
+def physical_icon_side(side: int, density: float) -> int:
+    """Return the side in device pixels that Qt asks of an icon drawn ``side`` logical pixels wide at ``density``.
+
+    Qt rounds a half up when it scales the size it asks of an icon, whereas Python's ``round`` rounds a half to the even
+    number: at 18 logical pixels and a density of 1.25 Qt asks for 23 pixels and ``round`` gives 22. An icon one pixel
+    smaller than the size Qt asks for is stretched by Qt, which blurs it and loses its pixel ratio, so the pixmap is
+    sized by Qt's own arithmetic.
+    """
+    return (QSize(side, side) * density).width()

gitpane/ui/look/reference_font.py

@@ -0,0 +1,19 @@
+"""Write the checked-out branch in bold wherever a reference name is listed."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtGui import QFont
+
+from gitpane.history.repository_value import ReferenceKind
+
+if TYPE_CHECKING:
+    from gitpane.history.repository_value import Reference
+
+
+def reference_font(font: QFont, reference: Reference) -> QFont:
+    """Distinguish the checked-out branch without emphasizing other refs at the same commit."""
+    font = QFont(font)
+    font.setBold(reference.is_head and reference.kind == ReferenceKind.HEADS)
+    return font

gitpane/ui/look/theme_color.py

@@ -0,0 +1,63 @@
+"""Derive the theme-dependent greys of GitPane's controls from the palette of the running appearance."""
+
+from __future__ import annotations
+
+from PySide6.QtGui import QColor, QPalette
+
+from gitpane.config import DARK_BACKGROUND_LIGHTNESS_LIMIT
+
+# Shares of the way from the window color to the text color, as the text shows on the window, that give the greys of a
+# dark theme. They were chosen on screen on the macOS dark palette, where they give #474747, #5a5a5a and #7c7c7c.
+# The button band below a form: a little lighter than the form's body, so the band stays apart from it.
+BUTTON_BAND_DARK_RATIO = 0.12
+# The face of buttons, drop-down lists, tabs, column headers and scroll bars: lighter than the window they sit on.
+CONTROL_DARK_RATIO = 0.23
+# Every line: list borders, frames, the band's top line and separators; the grey of the lines between tool bars.
+LINE_DARK_RATIO = 0.425
+
+
+def is_dark_palette(palette: QPalette) -> bool:
+    """Tell whether text is drawn on a dark background, the signal to leave light-theme captures aside."""
+    return palette.color(QPalette.ColorRole.Base).lightnessF() < DARK_BACKGROUND_LIGHTNESS_LIMIT
+
+
+def toward_text(palette: QPalette, ratio: float) -> QColor:
+    """Return the window color moved ``ratio`` of the way towards the text color as it shows on the window.
+
+    The text color is composed with its own transparency first: macOS gives a white text at 85 % opacity, and blending
+    from the raw white would give lighter greys than the ones chosen on screen.
+    """
+    window, text = palette.color(QPalette.ColorRole.Window), palette.color(QPalette.ColorRole.WindowText)
+    channels: list[float] = []
+    for window_channel, text_channel in ((window.redF(), text.redF()), (window.greenF(), text.greenF()), (window.blueF(), text.blueF())):
+        shown_text_channel = window_channel + (text_channel - window_channel) * text.alphaF()
+        channels.append(window_channel + (shown_text_channel - window_channel) * ratio)
+    red, green, blue = channels
+    return QColor.fromRgbF(red, green, blue)
+
+
+def theme_band_color(palette: QPalette) -> QColor:
+    """Return the grey of a form's button band in a dark theme: a little lighter than the window, so the band stays apart."""
+    return toward_text(palette, BUTTON_BAND_DARK_RATIO)
+
+
+def theme_control_color(palette: QPalette) -> QColor:
+    """Return the face grey of buttons, drop-down lists, tabs, column headers and scroll bars in a dark theme."""
+    return toward_text(palette, CONTROL_DARK_RATIO)
+
+
+def theme_line_color(palette: QPalette) -> QColor:
+    """Return the grey of every line in a dark theme: list borders, frames, the band's top line and separators."""
+    return toward_text(palette, LINE_DARK_RATIO)
+
+
+def line_number_gutter_color(palette: QPalette) -> QColor:
+    """Return the background of the line-number gutter of the diff and file readers.
+
+    A light theme keeps the palette's alternate row color. A dark one takes the band grey: macOS gives the
+    application palette a light grey alternate row color meant for lists only, and the gutter, which is not a list,
+    would show white numbers on it that cannot be read.
+    """
+    if is_dark_palette(palette):
+        return theme_band_color(palette)
+    return palette.color(QPalette.ColorRole.AlternateBase)

gitpane/ui/look/theme_look.py

@@ -0,0 +1,95 @@
+"""Lay a window's theme-dependent look again each time the desktop switches to the light or the dark appearance.
+
+Some colors and style sheets are set once, when a window is built: the body and band colors of the Git Extensions
+forms, the light-theme style sheets of their buttons and fields. They do not follow a change of appearance on their
+own, so a window opened in light would stay light after a switch to dark. Each window gathers the functions that lay
+that look, and one follower per window calls them again when a color they are worked out from changes.
+
+The follower watches the top-level window rather than each widget: Qt does not pass palette notices on to children that
+carry a style sheet, while the window always gets the application palette notice. It reacts to palette notices and not
+to the theme notice: the theme notice comes before GitPane has laid the new application palette, so the colors read
+then would still be the old ones.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, Qt
+from PySide6.QtGui import QColor, QPalette
+from PySide6.QtWidgets import QApplication
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+PALETTE_EVENT_TYPE_SET = frozenset({QEvent.Type.PaletteChange, QEvent.Type.ApplicationPaletteChange})
+# Application palette colors every theme look is worked out from: the body and field surfaces, the band and line greys
+# (from the window color towards the window text), the field text, and the selection colors a list copies into its own
+# palette, which another accent changes on its own.
+THEME_PALETTE_ROLES = (QPalette.ColorRole.Base, QPalette.ColorRole.Window, QPalette.ColorRole.WindowText, QPalette.ColorRole.Text, QPalette.ColorRole.Highlight,
+                       QPalette.ColorRole.HighlightedText)
+
+
+def theme_palette_key(palette: QPalette) -> tuple[str, ...]:
+    """Return the colors of the palette a theme look is built from, transparency included, so any change of one of them is noticed.
+
+    Light or dark alone is not enough: switching from one dark palette to another (Windows high contrast, another
+    accent) keeps the variant but changes the colors a window copied. The transparency counts too: macOS writes its
+    text as white at 85 %, and the greys worked out from it depend on that share.
+    """
+    color_names: list[str] = []
+    for role in THEME_PALETTE_ROLES:
+        color_names.append(palette.color(role).name(QColor.NameFormat.HexArgb))
+    return tuple(color_names)
+
+
+class ThemeLookFollower(QObject):
+    """Call a window's theme look functions again, in the order they were given, when the application palette's colors change.
+
+    The window's own palette and style sheet writes raise palette notices too, so the looks run only when a color they
+    are built from really changed in the application palette, which no look ever writes. The new colors are recorded
+    before the looks run, so the notices the looks raise start nothing. Several notices for one switch end on the last
+    palette: each one compares against the colors the looks were last laid with.
+    """
+
+    def __init__(self, window: QWidget) -> None:
+        """Watch the window's palette notices; the follower belongs to the window and goes with it."""
+        super().__init__(window)
+        self.looks: list[Callable[[], None]] = []
+        self.theme_key = theme_palette_key(QApplication.palette())
+        window.installEventFilter(self)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Lay every look again when a palette notice comes with new application colors; the event goes on as usual.
+
+        A look that raises is logged and the next ones still run: the colors are already recorded, so a look skipped
+        here would leave its part of the window in the old appearance until the next switch.
+        """
+        if event.type() not in PALETTE_EVENT_TYPE_SET:
+            return False
+        theme_key = theme_palette_key(QApplication.palette())
+        if theme_key == self.theme_key:
+            return False
+        self.theme_key = theme_key
+        for look in list(self.looks):
+            try:
+                look()
+            except Exception:
+                logging.getLogger(__name__).exception("A theme look failed after an appearance change; the window's other looks still run")
+        return False
+
+
+def follow_theme(window: QWidget, look: Callable[[], None]) -> ThemeLookFollower:
+    """Have ``look`` called again each time the light or dark colors of the application change while the window exists.
+
+    ``look`` lays something of the window's look that is decided on the application palette; it has already been laid
+    once by the window. One follower serves the whole window: it is created on the first call and reused afterwards.
+    """
+    follower = window.findChild(ThemeLookFollower, "", Qt.FindChildOption.FindDirectChildrenOnly)
+    if follower is None:
+        follower = ThemeLookFollower(window)
+    follower.looks.append(look)
+    return follower

gitpane/ui/look/theme_palette.py

@@ -0,0 +1,173 @@
+"""Git Extensions colors for light desktop themes: white fields on Windows' control grey.
+
+Light Linux themes often give the window and the fields one same color (beige in the Windows XP Luna copies, white in
+Yaru), so nothing shows where to type. Git Extensions always draws its fields white on the grey of Windows' controls;
+GitPane does the same in every light theme. A dark theme keeps its own palette: the light captures would glare there.
+A desktop that asks for high contrast keeps its own palette too: its colors are chosen for readability, and Windows
+counts its High Contrast White theme as light.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, Qt, QTimer
+from PySide6.QtGui import QColor, QPalette
+
+from gitpane.ui.look.theme_color import is_dark_palette
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QApplication, QWidget
+
+# The white of the body and of the fields of the Git Extensions windows, sampled on its Cherry pick commit capture.
+BODY_LIGHT_COLOR = "#ffffff"
+# Windows' own control grey: the button area of a native message box, and the empty reference rows of the Git Extensions
+# commit box. Sampled on the Merge conflicts and Cherry pick commit captures.
+WINDOWS_CONTROL_LIGHT_COLOR = "#f0f0f0"
+PALETTE_COLOR_GROUPS = (QPalette.ColorGroup.Active, QPalette.ColorGroup.Inactive, QPalette.ColorGroup.Disabled)
+
+
+def desktop_prefers_high_contrast(application: QApplication) -> bool:
+    """Tell whether the desktop asks applications for high contrast, as Windows does in its High Contrast themes."""
+    # PySide invalidates the accessibility hints wrapper as soon as the style hints wrapper it came from is collected,
+    # so a chained call fails with "already deleted"; the style hints are kept in a name while the hints are read.
+    style_hints = application.styleHints()
+    return style_hints.accessibility().contrastPreference() == Qt.ContrastPreference.HighContrast
+
+
+def light_field_palette(source: QPalette, *, high_contrast: bool = False) -> QPalette:
+    """Return the desktop palette with the Git Extensions window and field colors when it is light, unchanged when dark or in high contrast.
+
+    Only the window and field backgrounds change; text, selection, tooltip and every other color stay the theme's, so
+    the theme's contrast between text and selection is kept. Alternate rows keep the theme's color unless it now
+    matches the white fields, in which case they take the control grey so the rows stay told apart. A disabled field
+    stays painted like the window when the theme paints it so, which keeps a disabled field looking disabled.
+    The source palette is never changed, and only the roles set here are pinned: every other role keeps following the
+    desktop theme.
+    """
+    palette = QPalette(source)
+    if high_contrast or is_dark_palette(source):
+        return palette
+    window_color = QColor(WINDOWS_CONTROL_LIGHT_COLOR)
+    field_color = QColor(BODY_LIGHT_COLOR)
+    for group in PALETTE_COLOR_GROUPS:
+        disabled_field_like_window = group == QPalette.ColorGroup.Disabled and source.color(group, QPalette.ColorRole.Base) == source.color(group, QPalette.ColorRole.Window)
+        group_field_color = window_color if disabled_field_like_window else field_color
+        palette.setColor(group, QPalette.ColorRole.Window, window_color)
+        palette.setColor(group, QPalette.ColorRole.Base, group_field_color)
+        if source.color(group, QPalette.ColorRole.AlternateBase) == group_field_color:
+            palette.setColor(group, QPalette.ColorRole.AlternateBase, window_color)
+    return palette
+
+
+def desktop_theme_palette(application: QApplication) -> QPalette:
+    """Return the palette the desktop theme gives the application, without the colors GitPane laid on top of it.
+
+    An application palette set by GitPane pins its window and field colors: Qt keeps them through a theme change and
+    only refreshes the other roles. Dropping it first is the only way to read the new theme's own window and field colors.
+    """
+    application.setPalette(QPalette())
+    return QPalette(application.palette())
+
+
+def widget_depth(widget: QWidget) -> int:
+    """Count a widget's ancestors, so a walk can reach every parent before its children."""
+    depth = 0
+    parent = widget.parentWidget()
+    while parent is not None:
+        depth += 1
+        parent = parent.parentWidget()
+    return depth
+
+
+def resolve_widget_palettes(application: QApplication) -> None:
+    """Make every widget already built take its parent's palette again, parents first; colors a widget set itself stay.
+
+    Workaround for a Qt propagation gap: reading the desktop palette drops GitPane's application palette and lays it
+    again right after. Widgets built before that (the Settings window GitPane opens at startup when Git cannot be used
+    is built before the desktop's first theme notice) kept the desktop theme's own colors in their inner widgets, so a
+    light theme that paints fields like the window showed fields of the window's color. Setting each widget's palette
+    to itself resolves it again against its parent, which is already done, and keeps the roles the widget set itself.
+    Widgets drawn by a style sheet are left to it: Qt asks not to set a palette on them.
+    """
+    widgets = sorted(application.allWidgets(), key=widget_depth)
+    for widget in widgets:
+        if widget.testAttribute(Qt.WidgetAttribute.WA_StyleSheet):
+            continue
+        widget.setPalette(widget.palette())
+
+
+class LightFieldPaletteFollower(QObject):
+    """Lay the Git Extensions colors again each time the desktop theme changes, so a light/dark switch needs no restart.
+
+    Qt announces a theme change to the style hints object, by a theme change event and, when the light or dark scheme
+    changes, by a signal; watching that one object costs nothing on the application's other events. Several notices
+    arrive for one switch, so the update is queued once and runs after them. The update itself only changes the
+    application palette, which raises no theme notice; a flag ignores any notice raised while it runs all the same.
+    """
+
+    def __init__(self, application: QApplication, read_theme_palette: Callable[[QApplication], QPalette],
+                 prefers_high_contrast: Callable[[QApplication], bool] = desktop_prefers_high_contrast) -> None:
+        """Watch the application's style hints; ``read_theme_palette`` returns the desktop theme's own palette, ``prefers_high_contrast`` the desktop's contrast choice."""
+        super().__init__(application)
+        self.application = application
+        self.read_theme_palette = read_theme_palette
+        self.prefers_high_contrast = prefers_high_contrast
+        self.applying = False
+        self.update_timer = QTimer(self)
+        self.update_timer.setSingleShot(True)
+        self.update_timer.setInterval(0)
+        self.update_timer.timeout.connect(self.update_palette)
+        style_hints = application.styleHints()
+        style_hints.installEventFilter(self)
+        style_hints.colorSchemeChanged.connect(self.schedule_update)
+        # PySide invalidates the accessibility hints wrapper once the style hints wrapper it came from is collected;
+        # both are kept for as long as this follower listens to them.
+        self.style_hints = style_hints
+        self.accessibility_hints = style_hints.accessibility()
+        self.accessibility_hints.contrastPreferenceChanged.connect(self.schedule_update)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Queue an update when Qt announces a desktop theme change; the event goes on as usual."""
+        if event.type() == QEvent.Type.ThemeChange:
+            self.schedule_update()
+        return False
+
+    def schedule_update(self) -> None:
+        """Queue one palette update, unless the notice comes from the update running now."""
+        if self.applying:
+            return
+        self.update_timer.start()
+
+    def update_palette(self) -> None:
+        """Read the desktop theme's palette again and lay the Git Extensions colors on it when it is light and not in high contrast.
+
+        Every widget already built then resolves its palette again, so no field keeps the colors seen while reading.
+        """
+        self.applying = True
+        try:
+            theme_palette = self.read_theme_palette(self.application)
+            self.application.setPalette(light_field_palette(theme_palette, high_contrast=self.prefers_high_contrast(self.application)))
+            resolve_widget_palettes(self.application)
+        finally:
+            self.applying = False
+
+
+def install_light_field_palette(application: QApplication, read_theme_palette: Callable[[QApplication], QPalette] = desktop_theme_palette,
+                                prefers_high_contrast: Callable[[QApplication], bool] = desktop_prefers_high_contrast) -> LightFieldPaletteFollower:
+    """Give the whole application the Git Extensions field colors when the desktop theme is light, and keep it so.
+
+    Called once at startup, before the first window, so every window and every field is built on these colors. The
+    returned object, owned by the application, follows later desktop theme and contrast changes; calling this again
+    reuses it. ``read_theme_palette`` reads the desktop theme's palette and ``prefers_high_contrast`` the desktop's
+    contrast choice; tests give stand-ins for the desktop.
+    """
+    application.setPalette(light_field_palette(application.palette(), high_contrast=prefers_high_contrast(application)))
+    for child in application.children():
+        if isinstance(child, LightFieldPaletteFollower):
+            child.read_theme_palette = read_theme_palette
+            child.prefers_high_contrast = prefers_high_contrast
+            return child
+    return LightFieldPaletteFollower(application, read_theme_palette, prefers_high_contrast)

gitpane/ui/look/warning_icon.py

@@ -0,0 +1,86 @@
+"""Paint the theme's symbolic warning icon in the warning colour when the theme has no coloured one.
+
+Some icon themes, such as GNOME's Adwaita, only carry a symbolic warning icon: a one-colour shape meant to be painted by
+the application in the colour of its text. Qt then finds no coloured warning icon in the theme and falls back on its
+own bright yellow triangle, which hardly stands out from a light window. GitPane takes the theme's symbolic shape
+instead and paints it in the orange of its warnings, the colour of its light or dark variant, so the icon reads on both
+appearances and looks like the one the desktop's own applications show. A theme that has a coloured warning icon keeps
+it exactly as the theme draws it, whatever its contrast with the window: its colours are the theme's choice, and KDE's
+Breeze, whose pale orange triangle around a white mark measures under the guidelines' ratio on a light window, still
+reads well on screen. Without any icon theme (Windows, macOS, offscreen), the icon of the style is kept.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QColor, QIcon, QPainter, QPixmap
+
+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 QSize
+    from PySide6.QtGui import QPalette
+
+# Names icon themes give the warning icon: the coloured one, and the one-colour shape meant to be painted by the application.
+COLOR_WARNING_ICON_NAME = "dialog-warning"
+SYMBOLIC_WARNING_ICON_NAME = "dialog-warning-symbolic"
+
+
+class WarningIconSource(Enum):
+    """Say where the warning icon GitPane shows comes from."""
+
+    STYLE = "style"
+    """The icon of the style, unchanged: the theme's coloured icon when it has one, otherwise the style's own drawing."""
+    TINTED_SYMBOLIC = "tinted_symbolic"
+    """The theme's symbolic shape, painted in the warning colour: the theme has no coloured icon to show."""
+
+
+def warning_icon_source(has_color_icon: bool, has_symbolic_icon: bool) -> WarningIconSource:
+    """Choose the warning icon from what the icon theme has: its coloured icon first, else its symbolic one painted, else the style's.
+
+    A coloured icon is the theme's own drawing, so it is kept as it is. Only a theme that has the symbolic shape and no
+    coloured icon gets the painted shape: without either, there is nothing better than the style's own drawing.
+    """
+    if has_color_icon:
+        return WarningIconSource.STYLE
+    if not has_symbolic_icon:
+        return WarningIconSource.STYLE
+    return WarningIconSource.TINTED_SYMBOLIC
+
+
+def tinted_icon(source: QIcon, sizes: list[QSize], color: QColor) -> QIcon:
+    """Return the icon drawn at each size with every visible pixel in one colour, the transparency of the source kept.
+
+    The colour replaces the source's own while its alpha shapes the result, so the edges keep their smoothing. Each image
+    keeps the device pixel ratio the source gave it, so a high-density screen gets as many pixels as it shows.
+    """
+    result_icon = QIcon()
+    for size in sizes:
+        pixmap = source.pixmap(size)
+        tinted = QPixmap(pixmap.size())
+        tinted.setDevicePixelRatio(pixmap.devicePixelRatio())
+        tinted.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(tinted)
+        painter.drawPixmap(0, 0, pixmap)
+        painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
+        painter.fillRect(tinted.rect(), color)
+        painter.end()
+        result_icon.addPixmap(tinted)
+    return result_icon
+
+
+def readable_warning_icon(style_icon: QIcon, palette: QPalette, sizes: list[QSize]) -> QIcon:
+    """Return the warning icon to show on a window of that palette: the style's icon, or the theme's symbolic shape in the warning colour.
+
+    The orange is the one GitPane writes its warnings in, its light or dark variant after the palette, so the icon keeps
+    the contrast of those warnings on either appearance.
+    """
+    source = warning_icon_source(QIcon.hasThemeIcon(COLOR_WARNING_ICON_NAME), QIcon.hasThemeIcon(SYMBOLIC_WARNING_ICON_NAME))
+    if source == WarningIconSource.STYLE:
+        return style_icon
+    color = QColor(result_color(ResultTone.WARNING, is_dark_palette(palette)))
+    return tinted_icon(QIcon.fromTheme(SYMBOLIC_WARNING_ICON_NAME), sizes, color)