First commit. Version 0.1.0

src/widget/container.rs

@@ -0,0 +1,374 @@
+// SPDX-License-Identifier: LGPL-2.1-only
+// Copyright (C) 2026 Liberux Labs, S. L. <info@liberux.net>
+
+use crate::types::{ Color, Corners };
+use crate::render::Canvas;
+use super::Element;
+
+/// 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.
+///
+/// ```rust,no_run
+/// # use ltk::{ column, container, row, text, Color, Element };
+/// # #[ derive( Clone ) ] enum Msg {}
+/// # fn _ex(
+/// #     icon: Element<Msg>,
+/// #     title: Element<Msg>,
+/// #     subtitle: Element<Msg>,
+/// # ) -> ( Element<Msg>, Element<Msg> ) {
+/// // 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 );
+/// # ( flat.into(), card.into() )
+/// # }
+/// ```
+pub struct Container<Msg: Clone>
+{
+	pub child:      Box<Element<Msg>>,
+	pub background: Option<Color>,
+	/// Slot id of a themed surface (resolved via
+	/// [`crate::theme::resolve_surface`]). When set, takes precedence
+	/// over `background` and paints the full Glass stack instead of a
+	/// flat colour fill.
+	pub surface:    Option<String>,
+	/// Per-corner radii applied to every painted layer of the
+	/// container chrome — flat fill, themed surface (gradient + outer
+	/// shadows + insets + backdrop blur). Stored as [`Corners`] so
+	/// callers can pin the rounded shape to one or two corners (a
+	/// panel pinned to the screen bottom, a side panel pinned to the
+	/// left edge, …) without hitting the renderer with an offset
+	/// trick.
+	pub corners:    Corners,
+	/// Padding on the top edge in logical px — gap between the
+	/// container's top boundary and its child.
+	pub pad_top:    f32,
+	/// Padding on the right edge in logical px.
+	pub pad_right:  f32,
+	/// Padding on the bottom edge in logical px.
+	pub pad_bottom: f32,
+	/// Padding on the left edge in logical px.
+	pub pad_left:   f32,
+	pub opacity:    f32,
+	/// Optional `( color, width_px )` border stroke painted around the
+	/// container's rounded rectangle, after the fill / surface and
+	/// before the child draws. `None` leaves the chrome flat.
+	pub border:     Option<( Color, f32 )>,
+}
+
+impl<Msg: Clone> Container<Msg>
+{
+	pub fn new( child: impl Into<Element<Msg>> ) -> Self
+	{
+		Self
+		{
+			child:      Box::new( child.into() ),
+			background: None,
+			surface:    None,
+			corners:    Corners::ZERO,
+			pad_top:    0.0,
+			pad_right:  0.0,
+			pad_bottom: 0.0,
+			pad_left:   0.0,
+			opacity:    1.0,
+			border:     None,
+		}
+	}
+
+	/// 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 border( mut self, color: Color, width: f32 ) -> Self
+	{
+		self.border = Some( ( color, width.max( 0.0 ) ) );
+		self
+	}
+
+	/// Set the background fill color. Ignored at paint time if a
+	/// themed [`surface`](Self::surface) is set and resolves against
+	/// the active theme.
+	pub fn background( mut self, color: Color ) -> Self
+	{
+		self.background = Some( color );
+		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`](Self::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 surface( mut self, slot: impl Into<String> ) -> Self
+	{
+		self.surface = Some( slot.into() );
+		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.
+	///
+	/// ```rust,no_run
+	/// # use ltk::{ container, text, Corners, Element };
+	/// # #[ derive( Clone ) ] enum Msg {}
+	/// # fn _ex() -> ( Element<Msg>, Element<Msg>, Element<Msg> ) {
+	/// // 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 ) );
+	/// # ( a.into(), b.into(), c.into() )
+	/// # }
+	/// ```
+	pub fn radius( mut self, corners: impl Into<Corners> ) -> Self
+	{
+		self.corners = corners.into();
+		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`](Self::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( mut self, p: f32 ) -> Self
+	{
+		self.pad_top    = p;
+		self.pad_right  = p;
+		self.pad_bottom = p;
+		self.pad_left   = p;
+		self
+	}
+
+	/// Set horizontal padding (left + right each).
+	pub fn padding_h( mut self, p: f32 ) -> Self
+	{
+		self.pad_left  = p;
+		self.pad_right = p;
+		self
+	}
+
+	/// Set vertical padding (top + bottom each).
+	pub fn padding_v( mut self, p: f32 ) -> Self
+	{
+		self.pad_top    = p;
+		self.pad_bottom = p;
+		self
+	}
+
+	/// Set the top edge padding only. Pairs with
+	/// [`padding_bottom`](Self::padding_bottom) for asymmetric
+	/// vertical insets.
+	pub fn padding_top( mut self, p: f32 ) -> Self
+	{
+		self.pad_top = p;
+		self
+	}
+
+	/// Set the right edge padding only.
+	pub fn padding_right( mut self, p: f32 ) -> Self
+	{
+		self.pad_right = p;
+		self
+	}
+
+	/// Set the bottom edge padding only.
+	pub fn padding_bottom( mut self, p: f32 ) -> Self
+	{
+		self.pad_bottom = p;
+		self
+	}
+
+	/// Set the left edge padding only.
+	pub fn padding_left( mut self, p: f32 ) -> Self
+	{
+		self.pad_left = p;
+		self
+	}
+
+	/// Set opacity for the entire container and its contents (0.0 = transparent, 1.0 = opaque).
+	pub fn opacity( mut self, alpha: f32 ) -> Self
+	{
+		self.opacity = alpha.clamp( 0.0, 1.0 );
+		self
+	}
+
+	/// Return the preferred `(width, height)` accounting for padding.
+	pub fn preferred_size( &self, max_width: f32, canvas: &Canvas ) -> ( f32, f32 )
+	{
+		let pad_x = self.pad_left + self.pad_right;
+		let pad_y = self.pad_top  + self.pad_bottom;
+		let inner_w = ( max_width - pad_x ).max( 0.0 );
+		let ( cw, ch ) = self.child.preferred_size( inner_w, canvas );
+		( cw + pad_x, ch + pad_y )
+	}
+
+	pub( crate ) fn map_msg<U>( self, f: &super::MapFn<Msg, U> ) -> Container<U>
+	where
+		U: Clone + 'static,
+		Msg: 'static,
+	{
+		Container
+		{
+			child:      Box::new( self.child.map_arc( f ) ),
+			background: self.background,
+			surface:    self.surface,
+			corners:    self.corners,
+			pad_top:    self.pad_top,
+			pad_right:  self.pad_right,
+			pad_bottom: self.pad_bottom,
+			pad_left:   self.pad_left,
+			opacity:    self.opacity,
+			border:     self.border,
+		}
+	}
+}
+
+/// Create a [`Container`] that wraps `child`.
+pub fn container<Msg: Clone>( child: impl Into<Element<Msg>> ) -> Container<Msg>
+{
+	Container::new( child )
+}
+
+#[ cfg( test ) ]
+mod tests
+{
+	use super::*;
+	use crate::layout::spacer::spacer;
+
+	#[ test ]
+	fn default_no_background()
+	{
+		let c = container::<()>( spacer() );
+		assert!( c.background.is_none() );
+	}
+
+	#[ test ]
+	fn padding_sets_all_four_sides()
+	{
+		let c = container::<()>( spacer() ).padding( 10.0 );
+		assert_eq!( c.pad_top,    10.0 );
+		assert_eq!( c.pad_right,  10.0 );
+		assert_eq!( c.pad_bottom, 10.0 );
+		assert_eq!( c.pad_left,   10.0 );
+	}
+
+	#[ test ]
+	fn padding_h_only_touches_left_and_right()
+	{
+		let c = container::<()>( spacer() ).padding_h( 8.0 );
+		assert_eq!( c.pad_left,  8.0 );
+		assert_eq!( c.pad_right, 8.0 );
+		assert_eq!( c.pad_top,    0.0 );
+		assert_eq!( c.pad_bottom, 0.0 );
+	}
+
+	#[ test ]
+	fn padding_v_only_touches_top_and_bottom()
+	{
+		let c = container::<()>( spacer() ).padding_v( 6.0 );
+		assert_eq!( c.pad_top,    6.0 );
+		assert_eq!( c.pad_bottom, 6.0 );
+		assert_eq!( c.pad_left,  0.0 );
+		assert_eq!( c.pad_right, 0.0 );
+	}
+
+	#[ test ]
+	fn per_edge_overrides_uniform_padding()
+	{
+		// Idiomatic "uniform with one override".
+		let c = container::<()>( spacer() )
+			.padding( 12.0 )
+			.padding_bottom( 22.0 );
+		assert_eq!( c.pad_top,    12.0 );
+		assert_eq!( c.pad_right,  12.0 );
+		assert_eq!( c.pad_bottom, 22.0 );
+		assert_eq!( c.pad_left,   12.0 );
+	}
+
+	#[ test ]
+	fn background_set()
+	{
+		use crate::types::Color;
+		let c = container::<()>( spacer() ).background( Color::BLACK );
+		assert!( c.background.is_some() );
+	}
+
+	#[ test ]
+	fn radius_set_uniform()
+	{
+		let c = container::<()>( spacer() ).radius( 12.0 );
+		assert_eq!( c.corners, Corners::all( 12.0 ) );
+	}
+
+	#[ test ]
+	fn radius_set_per_corner()
+	{
+		let c = container::<()>( spacer() ).radius( Corners::top( 16.0 ) );
+		assert_eq!( c.corners.tl, 16.0 );
+		assert_eq!( c.corners.tr, 16.0 );
+		assert_eq!( c.corners.br, 0.0 );
+		assert_eq!( c.corners.bl, 0.0 );
+	}
+
+	#[ test ]
+	fn radius_set_tuple()
+	{
+		let c = container::<()>( spacer() ).radius( ( 8.0, 4.0, 2.0, 1.0 ) );
+		assert_eq!( c.corners.tl, 8.0 );
+		assert_eq!( c.corners.tr, 4.0 );
+		assert_eq!( c.corners.br, 2.0 );
+		assert_eq!( c.corners.bl, 1.0 );
+	}
+
+	#[ test ]
+	fn default_no_surface()
+	{
+		let c = container::<()>( spacer() );
+		assert!( c.surface.is_none() );
+	}
+
+	#[ test ]
+	fn surface_stores_slot_id()
+	{
+		let c = container::<()>( spacer() ).surface( "surface-card" );
+		assert_eq!( c.surface.as_deref(), Some( "surface-card" ) );
+	}
+}
+