139 lines
3.7 KiB
Rust
139 lines
3.7 KiB
Rust
// SPDX-License-Identifier: LGPL-2.1-only
|
|
// Copyright (C) 2026 Liberux Labs, S. L. <info@liberux.net>
|
|
|
|
use crate::render::Canvas;
|
|
use super::Element;
|
|
|
|
/// Wraps an [`Element`] so that a [`Row`](crate::layout::row::Row) treats it
|
|
/// like a [`Spacer`](crate::layout::spacer::Spacer) for leftover-width
|
|
/// distribution, but draws the child inside the allocated rect.
|
|
///
|
|
/// Use this to make a non-trivial child fill remaining width without resorting
|
|
/// to a hard-coded `max_width`. The row computes how much width is left after
|
|
/// the fixed-size siblings, splits it across all flex / spacer children
|
|
/// proportionally to their `weight`, and gives the flex its share. The wrapped
|
|
/// child sees that share as its layout rect — text inside it triggers its own
|
|
/// elide path on overflow, columns adjust their inner width, etc.
|
|
///
|
|
/// ```rust,no_run
|
|
/// # use ltk::{ column, flex, row, Element };
|
|
/// # #[ derive( Clone ) ] enum Msg {}
|
|
/// # fn _ex(
|
|
/// # icon: Element<Msg>,
|
|
/// # title: Element<Msg>,
|
|
/// # subtitle: Element<Msg>,
|
|
/// # ) -> Element<Msg> {
|
|
/// row()
|
|
/// .push( icon )
|
|
/// .push( flex( column().push( title ).push( subtitle ) ) )
|
|
/// .into()
|
|
/// # }
|
|
/// ```
|
|
///
|
|
/// Currently only [`Row`](crate::layout::row::Row) honours flex distribution.
|
|
/// Inside a [`Column`](crate::layout::column::Column) a flex child behaves
|
|
/// like a regular zero-width child along the main axis — vertical flex is not
|
|
/// yet implemented.
|
|
pub struct Flex<Msg: Clone>
|
|
{
|
|
pub child: Box<Element<Msg>>,
|
|
pub weight: u32,
|
|
}
|
|
|
|
impl<Msg: Clone> Flex<Msg>
|
|
{
|
|
pub fn new( child: impl Into<Element<Msg>> ) -> Self
|
|
{
|
|
Self
|
|
{
|
|
child: Box::new( child.into() ),
|
|
weight: 1,
|
|
}
|
|
}
|
|
|
|
/// Relative weight when sharing leftover width with other flex / spacer
|
|
/// children in the same row (default `1`). A flex with `weight = 2`
|
|
/// claims twice the space of a sibling with `weight = 1`.
|
|
pub fn weight( mut self, w: u32 ) -> Self
|
|
{
|
|
self.weight = w;
|
|
self
|
|
}
|
|
|
|
pub fn preferred_size( &self, max_width: f32, canvas: &Canvas ) -> ( f32, f32 )
|
|
{
|
|
// Width contribution to the parent row is zero — the actual width
|
|
// comes from the flex distribution. Height comes from the child so
|
|
// the row's row-height calculation still picks us up.
|
|
let ( _, h ) = self.child.preferred_size( max_width, canvas );
|
|
( 0.0, h )
|
|
}
|
|
|
|
pub( crate ) fn map_msg<U>( self, f: &super::MapFn<Msg, U> ) -> Flex<U>
|
|
where
|
|
U: Clone + 'static,
|
|
Msg: 'static,
|
|
{
|
|
Flex
|
|
{
|
|
child: Box::new( self.child.map_arc( f ) ),
|
|
weight: self.weight,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn flex<Msg: Clone>( child: impl Into<Element<Msg>> ) -> Flex<Msg>
|
|
{
|
|
Flex::new( child )
|
|
}
|
|
|
|
impl<Msg: Clone + 'static> From<Flex<Msg>> for Element<Msg>
|
|
{
|
|
fn from( f: Flex<Msg> ) -> Self
|
|
{
|
|
Element::Flex( f )
|
|
}
|
|
}
|
|
|
|
#[ cfg( test ) ]
|
|
mod tests
|
|
{
|
|
use super::*;
|
|
use crate::layout::spacer::spacer;
|
|
use crate::render::Canvas;
|
|
|
|
fn make_canvas() -> Canvas { Canvas::new( 800, 600 ) }
|
|
|
|
#[ test ]
|
|
fn new_defaults_to_weight_one()
|
|
{
|
|
let f = Flex::<()>::new( spacer() );
|
|
assert_eq!( f.weight, 1 );
|
|
}
|
|
|
|
#[ test ]
|
|
fn weight_builder_sets_relative_weight()
|
|
{
|
|
let f = Flex::<()>::new( spacer() ).weight( 5 );
|
|
assert_eq!( f.weight, 5 );
|
|
}
|
|
|
|
#[ test ]
|
|
fn preferred_size_reports_zero_width_so_row_treats_it_as_filler()
|
|
{
|
|
let canvas = make_canvas();
|
|
let f = Flex::<()>::new( spacer().width( 100.0 ).height( 40.0 ) );
|
|
let ( w, _ ) = f.preferred_size( 600.0, &canvas );
|
|
assert_eq!( w, 0.0, "flex must contribute zero width to the row's intrinsic-width sum" );
|
|
}
|
|
|
|
#[ test ]
|
|
fn preferred_size_passes_child_height_through()
|
|
{
|
|
let canvas = make_canvas();
|
|
let f = Flex::<()>::new( spacer().width( 100.0 ).height( 40.0 ) );
|
|
let ( _, h ) = f.preferred_size( 600.0, &canvas );
|
|
assert_eq!( h, 40.0 );
|
|
}
|
|
}
|