From db41b19e4aab5416a184aff74fb681777100f7f4 Mon Sep 17 00:00:00 2001 From: Ren Amamiya Date: Sat, 14 Nov 2026 11:15:39 +0700 Subject: [PATCH] theme: add transparency knob for material fill --- crates/theme/src/colors.rs | 16 +++-- crates/theme/src/lib.rs | 10 +++ crates/theme/src/resolve.rs | 128 +++++++++++++++++++++++++++++++++++- 3 files changed, 146 insertions(+), 8 deletions(-) diff --git a/crates/theme/src/colors.rs b/crates/theme/src/colors.rs index 6c047c9..14a9174 100644 --- a/crates/theme/src/colors.rs +++ b/crates/theme/src/colors.rs @@ -3,7 +3,7 @@ use gpui::{Hsla, hsla, rgb}; -use crate::ThemeVariant; +use crate::{DEFAULT_TRANSPARENCY, MIN_MATERIAL_FILL_DARK, MIN_MATERIAL_FILL_LIGHT, ThemeVariant}; fn hex(hex: u32) -> Hsla { rgb(hex).into() @@ -136,6 +136,7 @@ impl MaterialTokens { selection: Hsla, variant: ThemeVariant, translucent: bool, + transparency: Option, ) -> Self { if !translucent { return Self { @@ -145,13 +146,16 @@ impl MaterialTokens { }; } - // Light tints heavier than dark: the blur carries less contrast there. - let background_alpha = match variant { - ThemeVariant::Light => 0.6, - ThemeVariant::Dark => 0.5, + let level = transparency.unwrap_or(DEFAULT_TRANSPARENCY) as f32 / 100.0; + + let floor = match variant { + ThemeVariant::Light => MIN_MATERIAL_FILL_LIGHT, + ThemeVariant::Dark => MIN_MATERIAL_FILL_DARK, }; + Self { - background: colors.background.alpha(background_alpha), + // The fill eases toward a floor instead of zero. + background: colors.background.alpha(1.0 - level * (1.0 - floor)), // A foreground wash keeps hover visible over any backdrop hue. hover: colors.foreground.alpha(0.06), selection: selection.alpha(0.85), diff --git a/crates/theme/src/lib.rs b/crates/theme/src/lib.rs index 18e6cd5..b8b61a6 100644 --- a/crates/theme/src/lib.rs +++ b/crates/theme/src/lib.rs @@ -104,6 +104,12 @@ pub const PIXEL_AVATAR_LIGHT_LIFT: f32 = 1.6; pub const PIXEL_AVATAR_LIGHT_CAP: f32 = 0.95; pub const PIXEL_AVATAR_DARK_FACTOR: f32 = 0.45; pub const PIXEL_AVATAR_DARK_FLOOR: f32 = 0.18; +/// The default window material transparency, as a percent (0 opaque, 100 the lightest fill). +pub const DEFAULT_TRANSPARENCY: u8 = 94; +/// The light-mode floor of the material fill. +pub const MIN_MATERIAL_FILL_LIGHT: f32 = 0.45; +/// The dark-mode floor of the material fill. +pub const MIN_MATERIAL_FILL_DARK: f32 = 0.15; /// Light or dark, resolved from the system appearance. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Deserialize)] @@ -664,6 +670,10 @@ pub struct CustomTheme { pub popover_elevation: Option, pub dialog_elevation: Option, pub control_elevation: Option, + /// Window material transparency as a percent (0 opaque, 100 pure blur). + /// + /// Note: windows platform is not supported + pub transparency: Option, } /// The engine's knobs and its platform source. diff --git a/crates/theme/src/resolve.rs b/crates/theme/src/resolve.rs index 291df40..841a35c 100644 --- a/crates/theme/src/resolve.rs +++ b/crates/theme/src/resolve.rs @@ -1,6 +1,6 @@ use crate::definition::ThemeDefinition; use crate::ramps::{AccentShades, Oklch, contrast_foreground, derive_shades, mix}; -use crate::system::SystemTheme; +use crate::system::{SourceKind, SystemTheme}; use crate::{ Borders, ColorTokens, CustomTheme, Elevations, MaterialTokens, Motion, Radius, Scrollbar, SizeTable, Spacing, ThemeVariant, Typography, @@ -198,8 +198,14 @@ pub(crate) fn resolve( ), }; + // The knob scales the fill over a platform-stated blur. + let transparency = custom + .transparency + .map(|level| level.min(100)) + .filter(|_| system.source != SourceKind::Windows && system.window_background.is_some()); + // Reduced transparency forces the window opaque. - let window_background = if system.accessibility.reduce_transparency { + let window_background = if system.accessibility.reduce_transparency || transparency == Some(0) { WindowBackgroundAppearance::Opaque } else { system @@ -303,6 +309,7 @@ pub(crate) fn resolve( ramps.primary.base, variant, window_background != WindowBackgroundAppearance::Opaque, + transparency, ); let platform_elevations = Elevations::for_platform(system.source, variant); @@ -638,6 +645,123 @@ mod tests { assert_eq!(resolved.material.selection, resolved.ramps.primary.base); } + #[test] + fn a_custom_transparency_level_scales_the_material_fill() { + let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); + stated.window_background = Some(WindowBackgroundAppearance::Blurred); + let custom = CustomTheme { + transparency: Some(80), + ..CustomTheme::default() + }; + let resolved = resolve(&stated, None, None, Some(custom)); + + assert_eq!( + resolved.window_background, + WindowBackgroundAppearance::Blurred + ); + assert!((resolved.material.background.a - 0.32).abs() < 1e-6); + + // Levels past 100 clamp, bottoming out at the dark floor. + let clamped = resolve( + &stated, + None, + None, + Some(CustomTheme { + transparency: Some(150), + ..CustomTheme::default() + }), + ); + assert!((clamped.material.background.a - 0.15).abs() < 1e-6); + } + + #[test] + fn light_mode_keeps_a_heavier_fill_at_full_transparency() { + let mut light_system = system(ThemeVariant::Light, PartialPalette::default(), None); + light_system.window_background = Some(WindowBackgroundAppearance::Blurred); + let mut dark_system = system(ThemeVariant::Dark, PartialPalette::default(), None); + dark_system.window_background = Some(WindowBackgroundAppearance::Blurred); + let maxed = CustomTheme { + transparency: Some(100), + ..CustomTheme::default() + }; + let light = resolve(&light_system, None, None, Some(maxed)); + let dark = resolve(&dark_system, None, None, Some(maxed)); + + assert!((light.material.background.a - 0.45).abs() < 1e-6); + assert!((dark.material.background.a - 0.15).abs() < 1e-6); + } + + #[test] + fn transparency_zero_opens_an_opaque_window() { + let mut stated = system(ThemeVariant::Dark, PartialPalette::default(), None); + stated.window_background = Some(WindowBackgroundAppearance::Blurred); + let resolved = resolve( + &stated, + None, + None, + Some(CustomTheme { + transparency: Some(0), + ..CustomTheme::default() + }), + ); + + assert_eq!( + resolved.window_background, + WindowBackgroundAppearance::Opaque + ); + assert_eq!(resolved.material.background, resolved.colors.background); + assert_eq!(resolved.material.hover, resolved.colors.muted); + assert_eq!(resolved.material.selection, resolved.ramps.primary.base); + } + + #[test] + fn the_transparency_knob_skips_windows_and_platforms_without_a_material() { + let mut windows = system(ThemeVariant::Dark, PartialPalette::default(), None); + windows.source = SourceKind::Windows; + windows.window_background = Some(WindowBackgroundAppearance::MicaBackdrop); + let resolved_windows = resolve( + &windows, + None, + None, + Some(CustomTheme { + transparency: Some(100), + ..CustomTheme::default() + }), + ); + + assert_eq!( + resolved_windows.window_background, + WindowBackgroundAppearance::MicaBackdrop + ); + // The knob's value is ignored on Windows; the default drives the fill. + let unset = resolve(&windows, None, None, None); + assert_eq!( + resolved_windows.material.background, + unset.material.background + ); + + let mut unstated = system(ThemeVariant::Dark, PartialPalette::default(), None); + unstated.window_background = None; + let resolved_unstated = resolve( + &unstated, + None, + None, + Some(CustomTheme { + transparency: Some(100), + ..CustomTheme::default() + }), + ); + + assert_eq!( + resolved_unstated.window_background, + WindowBackgroundAppearance::Opaque + ); + assert_eq!( + resolved_unstated.material.background, + resolved_unstated.colors.background + ); + } + #[test] fn overlay_is_translucent_and_overridable() { let light = resolve(