feat: support icon color - followup

demo/model_app.py

@@ -2,6 +2,7 @@
 from typing import TYPE_CHECKING, cast
 
 from qtpy.QtCore import QFile, QFileInfo, QSaveFile, Qt, QTextStream
+from qtpy.QtGui import QColor, QPalette
 from qtpy.QtWidgets import QApplication, QFileDialog, QMessageBox, QTextEdit
 
 from app_model import Application, types
@@ -149,6 +150,35 @@ def paste(self) -> None:
     def close(self) -> bool:
         return super().close()
 
+    def switch_palette(self) -> None:
+        if getattr(self, "_old_palette", None):
+            new_palette, self._old_palette = self._old_palette, QApplication.palette()
+            QApplication.setPalette(new_palette)
+            return
+
+        # make the dark palette first time
+        self._old_palette = QApplication.palette()
+
+        palette = QPalette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(53, 53, 53))
+        palette.setColor(QPalette.ColorRole.Base, QColor(35, 35, 35))
+
+        palette.setColor(QPalette.ColorRole.WindowText, Qt.GlobalColor.white)
+        palette.setColor(QPalette.ColorRole.Text, Qt.GlobalColor.white)
+        palette.setColor(QPalette.ColorRole.ButtonText, Qt.GlobalColor.white)
+
+        palette.setColor(QPalette.ColorRole.Highlight, QColor(80, 80, 80))
+        palette.setColor(QPalette.ColorRole.HighlightedText, Qt.GlobalColor.white)
+        QApplication.setPalette(palette)
+
+    def switch_theme_mode(self) -> None:
+        modes = (None, "dark", "light")
+        current = modes.index(self._app.theme_mode)
+        next_theme = modes[(current + 1) % 3]
+        self._app.theme_mode = next_theme
+        if sb := self.statusBar():
+            sb.showMessage(f"Current app theme: {next_theme}")
+
 
 # Actions defined declaratively outside of QMainWindow class ...
 # menus and toolbars will be made and added automatically
@@ -213,7 +243,11 @@ class CommandId:
     ),
     types.Action(
         id="cut",
-        icon="fa6-solid:scissors",
+        icon={
+            "light": "fa6-solid:scissors",
+            "color_dark": "#ff0000",
+            "color_light": "#0000ff",
+        },
         title="Cut",
         keybindings=[types.StandardKeyBinding.Cut],
         enablement="copyAvailable",
@@ -248,6 +282,33 @@ class CommandId:
         menus=[{"id": MenuId.HELP}],
         callback=MainWindow.about,
     ),
+    types.Action(
+        id="switch_palette",
+        icon="fa6-solid:palette",
+        title="Switch dark/light theme",
+        status_tip=(
+            "Switch between dark and light Qt Palette. This affects "
+            "icons, unless a theme has been explicitly set on the application level."
+        ),
+        menus=[{"id": MenuId.HELP}],
+        callback=MainWindow.switch_palette,
+    ),
+    types.Action(
+        id="switch_theme_mode",
+        icon={
+            "dark": "fa6-solid:sun",
+            "light": "fa6-solid:moon",
+            "color_dark": "#ff0000",
+            "color_light": "#0000ff",
+        },
+        title="Rotate between dark, light, and unset theme.",
+        status_tip=(
+            "Rotate between dark, light, and unset theme. This affects "
+            "theme icons and has precedence over the theming based on the QPalette."
+        ),
+        menus=[{"id": MenuId.HELP}],
+        callback=MainWindow.switch_theme_mode,
+    ),
 ]
 
 

src/app_model/_app.py

@@ -67,6 +67,11 @@ class Application:
         (Optionally) provide a context to use for this application. If a
         `MutableMapping` is provided, it will be used to create a `Context` instance.
         If `None` (the default), a new `Context` instance will be created.
+    theme_mode : Literal["dark", "light"] | None
+        Theme mode to use when picking the color of icons. Must be one of "dark",
+        "light", or None.  When `Application.theme_mode` is "dark", icons will be
+        generated using their "color_dark" color (which should be a light color),
+        and vice versa. If not provided, backends may guess the current theme mode.
 
     Attributes
     ----------
@@ -83,6 +88,7 @@ class Application:
     """
 
     destroyed = Signal(str)
+    theme_mode_changed = Signal(str)
     _instances: ClassVar[dict[str, Application]] = {}
 
     def __init__(
@@ -126,6 +132,7 @@ def __init__(
         )
         self._menus = menus_reg_class()
         self._keybindings = keybindings_reg_class()
+        self._theme_mode: Literal["dark", "light"] | None = None
 
         self.injection_store.on_unannotated_required_args = "ignore"
 
@@ -166,6 +173,26 @@ def context(self) -> Context:
         """Return the [`Context`][app_model.expressions.Context] for this application."""  # noqa E501
         return self._context
 
+    @property
+    def theme_mode(self) -> Literal["dark", "light"] | None:
+        """Return the theme mode for this `Application`."""
+        return self._theme_mode
+
+    @theme_mode.setter
+    def theme_mode(self, value: Literal["dark", "light"] | None) -> None:
+        """Set the theme mode for this `Application`.
+
+        Must be one of "dark", "light", or None.
+        If not provided, backends may guess at the current theme.
+        """
+        if value not in (None, "dark", "light"):
+            raise ValueError(
+                f"theme_mode must be one of 'dark', 'light', or None, not {value!r}"
+            )
+        if value != self._theme_mode:
+            self._theme_mode = value
+            self.theme_mode_changed(value)
+
     @classmethod
     def get_or_create(cls, name: str) -> Application:
         """Get app named `name` or create and return a new one if it doesn't exist."""

src/app_model/backends/qt/_qaction.py

@@ -100,16 +100,16 @@ def __init__(
             self.setText(command_rule.short_title)  # pragma: no cover
         else:
             self.setText(command_rule.title)
-        if command_rule.icon:
-            self.setIcon(to_qicon(command_rule.icon))
-        self.setIconVisibleInMenu(command_rule.icon_visible_in_menu)
+        self._update_icon()
+        self.setIconVisibleInMenu(self._cmd_rule.icon_visible_in_menu)
         if command_rule.status_tip:
             self.setStatusTip(command_rule.status_tip)
         if command_rule.toggled is not None:
             self.setCheckable(True)
             self._refresh()
         tooltip_with_keybinding = f"{self._tooltip} {self._keybinding_tooltip}".rstrip()
         self.setToolTip(tooltip_with_keybinding)
+        self._app.theme_mode_changed.connect(self._update_icon)
 
     def setText(self, text: str | None) -> None:
         super().setText(text)
@@ -120,6 +120,12 @@ def _update_keybinding(self) -> None:
         tooltip_with_keybinding = f"{self._tooltip} {self._keybinding_tooltip}".rstrip()
         self.setToolTip(tooltip_with_keybinding)
 
+    def _update_icon(self) -> None:
+        if self._cmd_rule.icon:
+            self.setIcon(
+                to_qicon(self._cmd_rule.icon, theme=self._app.theme_mode, parent=self)
+            )
+
     def update_from_context(self, ctx: Mapping[str, object]) -> None:
         """Update the enabled state of this menu item from `ctx`."""
         self.setEnabled(expr.eval(ctx) if (expr := self._cmd_rule.enablement) else True)

src/app_model/backends/qt/_qmainwindow.py

@@ -2,8 +2,8 @@
 
 from typing import TYPE_CHECKING
 
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QMainWindow, QWidget
+from qtpy.QtCore import QEvent, Qt
+from qtpy.QtWidgets import QApplication, QMainWindow, QWidget
 
 from app_model import Application
 
@@ -12,13 +12,17 @@
 if TYPE_CHECKING:
     from collections.abc import Collection, Mapping, Sequence
 
+    from qtpy.QtCore import QObject
+
 
 class QModelMainWindow(QMainWindow):
     """QMainWindow with app-model support."""
 
     def __init__(self, app: Application | str, parent: QWidget | None = None) -> None:
         super().__init__(parent)
         self._app = Application.get_or_create(app) if isinstance(app, str) else app
+        if qapp := QApplication.instance():
+            qapp.installEventFilter(self)
 
     def setModelMenuBar(
         self, menu_ids: Mapping[str, str] | Sequence[str | tuple[str, str]]
@@ -50,3 +54,12 @@ def addModelToolBar(
         else:
             self.addToolBar(toolbar)
         return toolbar
+
+    def eventFilter(self, a0: QObject | None, a1: QEvent | None) -> bool:
+        if a1 is not None and a1.type() in (
+            QEvent.Type.ApplicationPaletteChange,
+            QEvent.Type.PaletteChange,
+            QEvent.Type.StyleChange,
+        ):
+            self._app.theme_mode_changed(self._app.theme_mode)
+        return False

src/app_model/backends/qt/_qmenu.py

@@ -133,8 +133,14 @@ def __init__(
         super().__init__(
             menu_id=submenu.submenu, app=app, title=submenu.title, parent=parent
         )
-        if submenu.icon:
-            self.setIcon(to_qicon(submenu.icon))
+        self._update_icon()
+        self._app.theme_mode_changed.connect(self._update_icon)
+
+    def _update_icon(self) -> None:
+        if self._submenu.icon:
+            self.setIcon(
+                to_qicon(self._submenu.icon, theme=self._app.theme_mode, parent=self)
+            )
 
     def update_from_context(self, ctx: Mapping[str, object]) -> None:
         """Update the enabled state of this menu item from `ctx`."""

src/app_model/backends/qt/_util.py

@@ -3,23 +3,67 @@
 from typing import TYPE_CHECKING
 
 from qtpy.QtCore import QUrl
-from qtpy.QtGui import QIcon
+from qtpy.QtGui import QIcon, QPalette
+from qtpy.QtWidgets import QApplication
 
 if TYPE_CHECKING:
     from typing import Literal
 
+    from qtpy.QtCore import QObject
+
     from app_model.types import Icon
 
 
-def to_qicon(icon: Icon, theme: Literal["dark", "light"] = "dark") -> QIcon:
+def luma(r: float, g: float, b: float) -> float:
+    """Calculate the relative luminance of a color."""
+    r = r / 12.92 if r <= 0.03928 else ((r + 0.055) / 1.055) ** 2.4
+    g = g / 12.92 if g <= 0.03928 else ((g + 0.055) / 1.055) ** 2.4
+    b = b / 12.92 if b <= 0.03928 else ((b + 0.055) / 1.055) ** 2.4
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+
+def background_luma(qobj: QObject | None = None) -> float:
+    """Return background luminance of the first top level widget or QApp."""
+    # using hasattr here because it will only work with a QWidget, but some of the
+    # things calling this function could conceivably only be a QObject
+    if hasattr(qobj, "palette"):
+        palette: QPalette = qobj.palette()  # type: ignore
+    elif wdgts := QApplication.topLevelWidgets():
+        palette = wdgts[0].palette()
+    else:  # pragma: no cover
+        palette = QApplication.palette()
+    window_bgrd = palette.color(QPalette.ColorRole.Window)
+    return luma(window_bgrd.redF(), window_bgrd.greenF(), window_bgrd.blueF())
+
+
+LIGHT_COLOR = "#BCB4B4"
+DARK_COLOR = "#6B6565"
+
+
+def to_qicon(
+    icon: Icon,
+    theme: Literal["dark", "light", None] = None,
+    color: str | None = None,
+    parent: QObject | None = None,
+) -> QIcon:
     """Create QIcon from Icon."""
     from superqt import QIconifyIcon, fonticon
 
+    if theme is None:
+        theme = "dark" if background_luma(parent) < 0.5 else "light"
+    if color is None:
+        # use DARK_COLOR icon for light themes and vice versa
+        color = (
+            (icon.color_dark or LIGHT_COLOR)
+            if theme == "dark"
+            else (icon.color_light or DARK_COLOR)
+        )
+
     if icn := getattr(icon, theme, ""):
         if icn.startswith("file://"):
             return QIcon(QUrl(icn).toLocalFile())
         elif ":" in icn:
-            return QIconifyIcon(icn)
+            return QIconifyIcon(icn, color=color)
         else:
-            return fonticon.icon(icn)
+            return fonticon.icon(icn, color=color)
     return QIcon()  # pragma: no cover

src/app_model/types/_icon.py

@@ -20,6 +20,11 @@ class Icon(_BaseModel):
         "[superqt.fonticon](https://pyapp-kit.github.io/superqt/utilities/fonticon/)"
         " keys, such as `fa6s.arrow_down`",
     )
+    color_dark: str | None = Field(
+        None,  # use light icon for dark themes
+        description="(Light) icon color to use for themes with dark backgrounds. "
+        "If not provided, a default is used.",
+    )
     light: str | None = Field(
         default=None,
         description="Icon path when a light theme is used. These may be "
@@ -28,6 +33,11 @@ class Icon(_BaseModel):
         "[superqt.fonticon](https://pyapp-kit.github.io/superqt/utilities/fonticon/)"
         " keys, such as `fa6s.arrow_down`",
     )
+    color_light: str | None = Field(
+        None,  # use dark icon for light themes
+        description="(Dark) icon color to use for themes with light backgrounds. "
+        "If not provided, a default is used",
+    )
 
     @classmethod
     def _validate(cls, v: Any) -> "Icon":
@@ -37,6 +47,11 @@ def _validate(cls, v: Any) -> "Icon":
             return v
         if isinstance(v, str):
             v = {"dark": v, "light": v}
+        if isinstance(v, dict):
+            if "dark" in v:
+                v.setdefault("light", v["dark"])
+            elif "light" in v:
+                v.setdefault("dark", v["light"])
         return cls(**v)
 
     # for v2
@@ -45,6 +60,11 @@ def _validate(cls, v: Any) -> "Icon":
     def _model_val(cls, v: dict) -> dict:
         if isinstance(v, str):
             v = {"dark": v, "light": v}
+        if isinstance(v, dict):
+            if "dark" in v:
+                v.setdefault("light", v["dark"])
+            elif "light" in v:
+                v.setdefault("dark", v["light"])
         return v
 
 
@@ -53,6 +73,8 @@ class IconDict(TypedDict):
 
     dark: str | None
     light: str | None
+    color_dark: str | None
+    color_light: str | None
 
 
 IconOrDict: TypeAlias = Icon | IconDict