Struct Container

pub struct Container<Msg: Clone> { /* private fields */ }

A transparent wrapper that adds a background color or a themed surface and padding around any child Element.

Does not consume a flat index — it is invisible to focus/hit-testing.

Two background styles. Container::background paints a flat colour rounded rect. Container::surface names a theme slot (a "type": "surface" entry in the active ThemeDocument) which resolves at paint time to a full Glass stack: gradient / solid fill, outer drop shadow, inset shadows, backdrop blur. surface takes precedence when both are set, and degrades to background (or to no background at all, when neither is set) if the slot is absent from the active theme — third-party themes that do not ship the named surface still render the content, just without the Glass chrome.

// Flat colour
let flat = container( text( "Hello" ) )
    .background( Color::rgb( 0.2, 0.2, 0.25 ) )
    .padding( 12.0 );

// Glass card backed by a named theme surface
let card = container(
    row()
        .push( icon )
        .push( column().push( title ).push( subtitle ) )
)
.surface( "surface-card" )
.radius( 32.0 )
.padding_h( 16.5 )
.padding_v( 24.0 );

Implementations

impl<Msg: Clone> Container<Msg>

pub fn new(child: impl Into<Element<Msg>>) -> Self

pub fn live_region(self, live: bool) -> Self

pub fn border(self, color: Color, width: f32) -> Self

Paint a rounded-rect stroke around the container with the given colour and pixel width. Useful for input fields, popovers and any chrome the design system specifies as outlined rather than filled.

pub fn background(self, paint: impl Into<Paint>) -> Self

Set the background fill. Accepts anything convertible to Paint — a plain Color (auto-wrapped in Paint::Solid) or an explicit crate::theme::LinearGradient / crate::theme::RadialGradient. Ignored at paint time if a themed surface is set and resolves against the active theme.

pub fn surface(self, slot: impl Into<String>) -> Self

Back the container with a themed surface slot. The slot id is resolved against the active ThemeDocument at paint time via crate::theme::resolve_surface; missing slots fall through to background or to no background at all.

Slot ids are documented by the theme. The default theme ships surface-card (generic Glass container) and the slider-specific slots; downstream themes are free to add their own.

pub fn radius(self, corners: impl Into<Corners>) -> Self

Set the corner radii for every painted layer of the container chrome. Accepts a single f32 (uniform radius — the common case, equivalent to Corners::all( r )), a tuple ( tl, tr, br, bl ) (CSS shorthand order), or any explicit Corners value.

// Uniform 16 px on all corners (single-value form).
let a = container( text( "child" ) ).radius( 16.0 );

// Rounded top corners only — for a panel pinned flush against
// the bottom edge of the screen.
let b = container( text( "child" ) ).radius( Corners::top( 16.0 ) );

// Custom four-corner radii.
let c = container( text( "child" ) ).radius( ( 16.0, 16.0, 0.0, 0.0 ) );

pub fn padding(self, p: impl Into<Length>) -> Self

Set uniform padding on all four sides — equivalent to setting padding_top, padding_right, padding_bottom, and padding_left to p. Asymmetric variants (padding_top, …) override individual edges, so calling this first and then a per-edge setter is the idiomatic way to express “uniform padding except for one edge”.

pub fn padding_h(self, p: impl Into<Length>) -> Self

Set horizontal padding (left + right each).

pub fn padding_v(self, p: impl Into<Length>) -> Self

Set vertical padding (top + bottom each).

pub fn padding_top(self, p: impl Into<Length>) -> Self

Set the top edge padding only. Pairs with padding_bottom for asymmetric vertical insets.

pub fn padding_right(self, p: impl Into<Length>) -> Self

Set the right edge padding only.

pub fn padding_bottom(self, p: impl Into<Length>) -> Self

Set the bottom edge padding only.

pub fn padding_left(self, p: impl Into<Length>) -> Self

Set the left edge padding only.

pub fn opacity(self, alpha: f32) -> Self

Set opacity for the entire container and its contents (0.0 = transparent, 1.0 = opaque).

pub fn max_width(self, w: f32) -> Self

Cap the container’s outer width in logical px. When the parent offers a wider rect, the container reports its preferred width as min( offered, w ) so it does not stretch to fill.

pub fn preferred_size(&self, max_width: f32, canvas: &Canvas) -> (f32, f32)

Return the preferred (width, height) accounting for padding.

Trait Implementations

impl<Msg: Clone> From<Container<Msg>> for Element<Msg>

fn from(c: Container<Msg>) -> Self

Converts to this type from the input type.