Struct ColorScheme 

pub struct ColorScheme {

    pub primary: AlphaColor<Srgb>,
    pub on_primary: AlphaColor<Srgb>,
    pub primary_container: AlphaColor<Srgb>,
    pub on_primary_container: AlphaColor<Srgb>,
    pub primary_fixed: AlphaColor<Srgb>,
    pub primary_fixed_dim: AlphaColor<Srgb>,
    pub on_primary_fixed: AlphaColor<Srgb>,
    pub on_primary_fixed_variant: AlphaColor<Srgb>,
    pub secondary: AlphaColor<Srgb>,
    pub on_secondary: AlphaColor<Srgb>,
    pub secondary_container: AlphaColor<Srgb>,
    pub on_secondary_container: AlphaColor<Srgb>,
    pub secondary_fixed: AlphaColor<Srgb>,
    pub secondary_fixed_dim: AlphaColor<Srgb>,
    pub on_secondary_fixed: AlphaColor<Srgb>,
    pub on_secondary_fixed_variant: AlphaColor<Srgb>,
    pub tertiary: AlphaColor<Srgb>,
    pub on_tertiary: AlphaColor<Srgb>,
    pub tertiary_container: AlphaColor<Srgb>,
    pub on_tertiary_container: AlphaColor<Srgb>,
    pub tertiary_fixed: AlphaColor<Srgb>,
    pub tertiary_fixed_dim: AlphaColor<Srgb>,
    pub on_tertiary_fixed: AlphaColor<Srgb>,
    pub on_tertiary_fixed_variant: AlphaColor<Srgb>,
    pub error: AlphaColor<Srgb>,
    pub on_error: AlphaColor<Srgb>,
    pub error_container: AlphaColor<Srgb>,
    pub on_error_container: AlphaColor<Srgb>,
    pub surface: AlphaColor<Srgb>,
    pub on_surface: AlphaColor<Srgb>,
    pub on_surface_variant: AlphaColor<Srgb>,
    pub surface_dim: AlphaColor<Srgb>,
    pub surface_bright: AlphaColor<Srgb>,
    pub surface_container_lowest: AlphaColor<Srgb>,
    pub surface_container_low: AlphaColor<Srgb>,
    pub surface_container: AlphaColor<Srgb>,
    pub surface_container_high: AlphaColor<Srgb>,
    pub surface_container_highest: AlphaColor<Srgb>,
    pub outline: AlphaColor<Srgb>,
    pub outline_variant: AlphaColor<Srgb>,
    pub shadow: AlphaColor<Srgb>,
    pub scrim: AlphaColor<Srgb>,
    pub inverse_surface: AlphaColor<Srgb>,
    pub inverse_on_surface: AlphaColor<Srgb>,
    pub inverse_primary: AlphaColor<Srgb>,
    pub surface_tint: AlphaColor<Srgb>,
}

The design-token vocabulary: the Theme bundle plus its component token tables, flat-re-exported from frust-theme so app code never names that crate directly. A root component reads the active theme via use_context::<Theme>(); a widget reads it during paint/layout via PaintCtx::theme_as/LayoutCtx::theme_as (or Theme::from_paint_ctx).

Includes the glass material tokens — this crate ships the opaque recipe, and a design system authors its own translucent one over the same types:

use frust::GlassScale;

let glass = GlassScale::opaque_material();
assert_eq!(glass.chrome.blur_radius_intent, 0.0);
assert!(glass.control.is_opaque());

Also the composable-theming surface: ThemeBuilder (defineTheme/copyWith analog), the no-lock-in typed extension slot (ThemeExtensions) plus its first consumer StatusPalette/StatusColors (success/warning/info), and the motion vocabulary (MotionDurations/EasingSet) — all flat-re-exported so an app (or a design-system plugin) authors a theme against frust::* alone. A full set of color roles for one brightness (light or dark), on Material 3’s role vocabulary.

46 non-deprecated roles (see module docs for the deprecated 3). This crate constructs one table, the language-free ColorScheme::neutral_light/ColorScheme::neutral_dark pair; a design system fills the same fields from its own source values in its own crate. Fields are normally opaque Colors — channel-appropriate translucency (e.g. for scrims) is applied by the widget/scene layer, not stored here — but a design system whose real token is itself translucent may store the non-opaque value rather than misrepresent it.

Fields

primary: AlphaColor<Srgb>

on_primary: AlphaColor<Srgb>

primary_container: AlphaColor<Srgb>

on_primary_container: AlphaColor<Srgb>

primary_fixed: AlphaColor<Srgb>

primary_fixed_dim: AlphaColor<Srgb>

on_primary_fixed: AlphaColor<Srgb>

on_primary_fixed_variant: AlphaColor<Srgb>

secondary: AlphaColor<Srgb>

on_secondary: AlphaColor<Srgb>

secondary_container: AlphaColor<Srgb>

on_secondary_container: AlphaColor<Srgb>

secondary_fixed: AlphaColor<Srgb>

secondary_fixed_dim: AlphaColor<Srgb>

on_secondary_fixed: AlphaColor<Srgb>

on_secondary_fixed_variant: AlphaColor<Srgb>

tertiary: AlphaColor<Srgb>

on_tertiary: AlphaColor<Srgb>

tertiary_container: AlphaColor<Srgb>

on_tertiary_container: AlphaColor<Srgb>

tertiary_fixed: AlphaColor<Srgb>

tertiary_fixed_dim: AlphaColor<Srgb>

on_tertiary_fixed: AlphaColor<Srgb>

on_tertiary_fixed_variant: AlphaColor<Srgb>

error: AlphaColor<Srgb>

on_error: AlphaColor<Srgb>

error_container: AlphaColor<Srgb>

on_error_container: AlphaColor<Srgb>

surface: AlphaColor<Srgb>

on_surface: AlphaColor<Srgb>

on_surface_variant: AlphaColor<Srgb>

surface_dim: AlphaColor<Srgb>

surface_bright: AlphaColor<Srgb>

surface_container_lowest: AlphaColor<Srgb>

surface_container_low: AlphaColor<Srgb>

surface_container: AlphaColor<Srgb>

surface_container_high: AlphaColor<Srgb>

surface_container_highest: AlphaColor<Srgb>

outline: AlphaColor<Srgb>

outline_variant: AlphaColor<Srgb>

shadow: AlphaColor<Srgb>

scrim: AlphaColor<Srgb>

inverse_surface: AlphaColor<Srgb>

inverse_on_surface: AlphaColor<Srgb>

inverse_primary: AlphaColor<Srgb>

surface_tint: AlphaColor<Srgb>

Implementations

impl ColorScheme

pub fn with_accent(self, accent: AlphaColor<Srgb>) -> ColorScheme

Replace the accent family from one seed color, Glyph-style.

Swaps exactly four roles: primary, on_primary, primary_container, and on_primary_container. All other 42 fields remain unchanged.

• primary: set to the provided accent color.
• on_primary: selected by relative luminance (WCAG contrast ratio ≥ 4.5:1 preferred) — prefer white if the accent is dark enough, else dark ink. A simple luminance threshold is used (see docs below).
• primary_container: an alpha-wash of the accent at 10% opacity, flattened over the scheme’s surface color to opaque.
• on_primary_container: set to the provided accent color (same as primary).

Luminance and Contrast

on_primary is determined by picking the ink that provides better contrast against the accent. Luminance is calculated via the WCAG relative luminance formula: L = 0.2126*R + 0.7152*G + 0.0722*B (after linearizing each channel from sRGB). If the accent’s luminance is below 0.5 (midpoint), white is preferred; otherwise, dark ink is preferred. This simple threshold provides acceptable contrast for most colors and avoids the overhead of computing the full contrast ratio (though a more precise contrast-ratio calculation could replace this later).

Works with Any Scheme

This method works on any ColorScheme — the neutral ramp below or any design system’s own table — without design-language branching.

Example

use peniko::Color;
use frust_theme::color::ColorScheme;

let base = ColorScheme::neutral_dark();
let red = Color::from_rgb8(0xFF, 0x00, 0x00);
let accent_scheme = base.with_accent(red);

assert_eq!(accent_scheme.primary, red);
assert_eq!(accent_scheme.on_primary_container, red);
// All other roles remain unchanged from the base scheme.

pub const fn neutral_light() -> ColorScheme

The neutral, design-language-free light ColorScheme: a plain achromatic surface/on-surface ramp, plus one restrained slate-blue accent filling the primary family — every other role (secondary/tertiary) stays gray too, since “neutral” means one accent, not a second or third hue. See crate::theme::Theme::neutral’s module docs for the design intent (“deliberately plain, not half-finished”).

Frust-authored, not sourced from any third-party design system — there is no external spec to cite here; values are chosen for legible contrast against their paired ink role (see ColorScheme::neutral_dark’s doc comment for the contrast rationale, verified by neutral_surface_on_surface_contrast_is_legible in this module’s tests). error/on_error/error_container/on_error_container are the one exception kept in real red — a functional/semantic signal (danger/destructive state), not a “look”, the same reasoning crate::theme::Theme::neutral uses to still attach crate::status::StatusPalette::neutral rather than a grayscale status set.

pub const fn neutral_dark() -> ColorScheme

The neutral, design-language-free dark ColorScheme — the dark-mode mirror of ColorScheme::neutral_light; see that constructor’s doc comment for the design rationale.

Contrast check (verified in this module’s tests): surface (#121212) against on_surface (#F2F2F2) is ~16.7:1, and ColorScheme::neutral_light’s equivalent pair is ~16.7:1 too — both far past the WCAG AA 4.5:1 normal-text floor.

Trait Implementations

impl Clone for ColorScheme

fn clone(&self) -> ColorScheme

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ColorScheme

impl Debug for ColorScheme

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for ColorScheme

fn eq(&self, other: &ColorScheme) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ColorScheme