Struct ShapeScale 

pub struct ShapeScale {
    pub none: f64,
    pub extra_small: f64,
    pub small: f64,
    pub medium: f64,
    pub large: f64,
    pub large_increased: f64,
    pub extra_large: f64,
    pub extra_large_increased: f64,
    pub extra_extra_large: f64,
    pub full: f64,
}

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. The 10 Material 3 corner-radius tokens, dp (logical px). full is represented as f64::INFINITY rather than a separate enum variant — resolve it against a concrete box size with ShapeScale::resolve, which clamps an infinite radius to half the box’s shorter side (a pill shape) and passes any finite radius through unchanged.

Fields

none: f64

extra_small: f64

small: f64

medium: f64

large: f64

large_increased: f64

extra_large: f64

extra_large_increased: f64

extra_extra_large: f64

full: f64

Always f64::INFINITY — resolve with ShapeScale::resolve.

Implementations

impl ShapeScale

pub const fn neutral() -> ShapeScale

The neutral, design-language-free shape scale — see the module docs for why these are the M3 numbers reused verbatim.

pub fn resolve(radius: f64, width: f64, height: f64) -> f64

Resolves a corner radius against a box’s shorter side (min(width, height)), clamping an infinite (ShapeScale::full) radius to a pill shape (shorter_side / 2.0) and any finite radius to itself (already-finite tokens never need clamping in the M3 scale, but a caller-supplied custom radius larger than the box would produce a visually broken corner, so this also caps at the pill radius as a safety net).

pub fn concentric_inner(outer_radius: f64, inset: f64) -> f64

Computes the inner corner radius for a concentrically-nested element.

The concentric-corner principle (Liquid Glass, iOS 26+; see WWDC 2025 session 219 and Apple HIG) defines inner and outer shapes’ rounded corners as sharing the same geometric center, with the inner radius derived from the outer radius minus the inset depth. This applies when a glass container (outer, radius outer_radius) nests a child container (inner, inset by inset on all sides); the child’s corner radius is max(outer_radius - inset, 0.0).

Formula

• If outer_radius is infinite (f64::INFINITY), return infinite (a full pill shape has no inner maximum).
• Otherwise, return max(outer_radius - inset, 0.0) (clamped at zero to prevent negative radii).

Examples

use frust_theme::ShapeScale;

// Normal nesting: glass bar (outer r=20) with inner pill (inset 4)
assert_eq!(ShapeScale::concentric_inner(20.0, 4.0), 16.0);

// Inset larger than outer: clamp at zero
assert_eq!(ShapeScale::concentric_inner(8.0, 12.0), 0.0);

// Infinite outer radius stays infinite (no clamping)
assert!(ShapeScale::concentric_inner(f64::INFINITY, 4.0).is_infinite());

Trait Implementations

impl Clone for ShapeScale

fn clone(&self) -> ShapeScale

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ShapeScale

impl Debug for ShapeScale

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

Formats the value using the given formatter.

impl PartialEq for ShapeScale

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ShapeScale