add windows theme source and platform icon resolvers

crates/theme/src/source/windows.rs

@@ -0,0 +1,199 @@
+//! Windows 11 adapter: WinRT `UISettings` semantic colors with a
+//! `Personalize` registry fallback, watched through `ColorValuesChanged`.
+
+use windows::Foundation::TypedEventHandler;
+use windows::UI::ViewManagement::{AccessibilitySettings, UIColorType, UISettings};
+use windows::Win32::Foundation::RPC_E_CHANGED_MODE;
+use windows::Win32::System::Com::{COINIT_APARTMENTTHREADED, CoInitializeEx};
+use windows::core::IInspectable;
+
+use super::ThemeSource;
+use super::signal::ReapplySignal;
+use crate::ThemeVariant;
+use crate::system::{AccessibilityPreferences, PartialPalette, SourceKind, SystemTheme};
+
+/// WinUI 11's `ControlCornerRadius`, in pixels at 100% scaling.
+const CONTROL_RADIUS_PX: f32 = 4.0;
+/// WinUI 11's default text-box height, in pixels at 100% scaling.
+const INPUT_HEIGHT_PX: f32 = 32.0;
+/// WinUI 11's default body text size, in pixels at 100% scaling.
+const ROOT_FONT_SIZE_PX: f32 = 14.0;
+
+/// The `Personalize` registry values, read once at startup as the fallback
+/// when the WinRT surface is unavailable.
+#[derive(Clone, Copy, Debug, Default)]
+struct RegistrySettings {
+    apps_use_light_theme: Option<bool>,
+    enable_transparency: Option<bool>,
+}
+
+impl RegistrySettings {
+    fn read() -> Self {
+        let personalize = || {
+            windows_registry::CURRENT_USER
+                .open(r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize")
+        };
+        Self {
+            apps_use_light_theme: personalize()
+                .and_then(|key| key.get_u32("AppsUseLightTheme"))
+                .ok()
+                .map(|value| value != 0),
+            enable_transparency: personalize()
+                .and_then(|key| key.get_u32("EnableTransparency"))
+                .ok()
+                .map(|value| value != 0),
+        }
+    }
+}
+
+pub(crate) struct WindowsSource {
+    ui_settings: UISettings,
+    accessibility_settings: AccessibilitySettings,
+    registry: RegistrySettings,
+    /// Keeps the main-thread channel loop alive.
+    _signal: Option<ReapplySignal>,
+}
+
+pub(crate) fn platform_source() -> Box<dyn ThemeSource> {
+    let initialized = unsafe { CoInitializeEx(None, COINIT_APARTMENTTHREADED) };
+
+    if initialized.is_err() && initialized != RPC_E_CHANGED_MODE {
+        eprintln!("theme: COM initialization failed: {initialized:?}");
+    }
+
+    match WindowsSource::new() {
+        Some(source) => Box::new(source),
+        None => {
+            eprintln!("theme: Windows system theme unavailable; using fallback");
+            Box::new(super::fallback::FallbackSource)
+        }
+    }
+}
+
+impl WindowsSource {
+    fn new() -> Option<Self> {
+        let ui_settings = match UISettings::new() {
+            Ok(ui_settings) => ui_settings,
+            Err(error) => {
+                eprintln!("theme: UISettings unavailable: {error}");
+                return None;
+            }
+        };
+
+        let accessibility_settings = match AccessibilitySettings::new() {
+            Ok(accessibility_settings) => accessibility_settings,
+            Err(error) => {
+                eprintln!("theme: AccessibilitySettings unavailable: {error}");
+                return None;
+            }
+        };
+
+        Some(Self {
+            ui_settings,
+            accessibility_settings,
+            registry: RegistrySettings::read(),
+            _signal: None,
+        })
+    }
+
+    fn color(&self, kind: UIColorType) -> Option<gpui::Hsla> {
+        let color = self.ui_settings.GetColorValue(kind).ok()?;
+        Some(gpui::Hsla::from(gpui::Rgba {
+            r: color.R as f32 / 255.0,
+            g: color.G as f32 / 255.0,
+            b: color.B as f32 / 255.0,
+            a: color.A as f32 / 255.0,
+        }))
+    }
+
+    fn accessibility(&self) -> AccessibilityPreferences {
+        AccessibilityPreferences {
+            high_contrast: self.accessibility_settings.HighContrast().unwrap_or(false),
+            // Windows states animations separately in Win32; not read yet.
+            reduce_motion: false,
+            reduce_transparency: self
+                .registry
+                .enable_transparency
+                .map(|enabled| !enabled)
+                .unwrap_or(false),
+        }
+    }
+}
+
+impl ThemeSource for WindowsSource {
+    fn snapshot(&self, variant: ThemeVariant) -> SystemTheme {
+        let accent = self.color(UIColorType::Accent);
+        let background = self.color(UIColorType::Background);
+        let foreground = self.color(UIColorType::Foreground);
+
+        let variant = background
+            .map(|background| {
+                if background.l >= 0.5 {
+                    ThemeVariant::Light
+                } else {
+                    ThemeVariant::Dark
+                }
+            })
+            .or(self.registry.apps_use_light_theme.map(|light| {
+                if light {
+                    ThemeVariant::Light
+                } else {
+                    ThemeVariant::Dark
+                }
+            }))
+            .unwrap_or(variant);
+
+        let text_scale = self.ui_settings.TextScaleFactor().unwrap_or(1.0);
+
+        SystemTheme {
+            variant,
+            accent,
+            // Windows states its ramp through UIColorType's accent variants.
+            palette: PartialPalette {
+                background,
+                foreground,
+                // Windows paints keyboard focus with the accent itself.
+                ring: accent,
+                ..PartialPalette::default()
+            },
+            control_radius: Some(gpui::px(CONTROL_RADIUS_PX)),
+            input_height: Some(gpui::px(INPUT_HEIGHT_PX)),
+            root_font_size: Some(gpui::px(ROOT_FONT_SIZE_PX * text_scale as f32)),
+            accessibility: self.accessibility(),
+            source: SourceKind::Windows,
+        }
+    }
+
+    fn install_watchers(&mut self, async_cx: gpui::AsyncApp) {
+        let signal = ReapplySignal::install(&async_cx);
+        let color_signal = signal.sender();
+        let color_handler = TypedEventHandler::<UISettings, IInspectable>::new(move |_, _| {
+            ReapplySignal::poke(&color_signal);
+            Ok(())
+        });
+
+        if let Err(error) = self.ui_settings.ColorValuesChanged(&color_handler) {
+            eprintln!("theme: color change watch failed: {error}");
+        }
+
+        let contrast_signal = signal.sender();
+        let contrast_handler =
+            TypedEventHandler::<AccessibilitySettings, IInspectable>::new(move |_, _| {
+                ReapplySignal::poke(&contrast_signal);
+                Ok(())
+            });
+
+        if let Err(error) = self
+            .accessibility_settings
+            .HighContrastChanged(&contrast_handler)
+        {
+            eprintln!("theme: high contrast watch failed: {error}");
+        }
+
+        self._signal = Some(signal);
+    }
+
+    fn label(&self) -> &'static str {
+        SourceKind::Windows.label()
+    }
+}