Struct SizeConstraints 

pub struct SizeConstraints {
    pub min: Size,
    pub preferred: Size,
    pub max: Option<Size>,
}

Size constraints returned by measure operations.

Captures the full sizing semantics for a widget:

• min: Minimum usable size (content clips below this)
• preferred: Ideal size for content display
• max: Maximum useful size (no benefit beyond this)

Invariants

The following must hold:

• min.width <= preferred.width <= max.map_or(u16::MAX, |m| m.width)
• min.height <= preferred.height <= max.map_or(u16::MAX, |m| m.height)

Example

use ftui_core::geometry::Size;
use ftui_widgets::SizeConstraints;

// A 10x3 text block with some flexibility
let constraints = SizeConstraints {
    min: Size::new(5, 1),       // Can shrink to 5 chars, 1 line
    preferred: Size::new(10, 3), // Ideal display
    max: Some(Size::new(20, 5)), // No benefit beyond this
};

// Clamp an allocation to these constraints
let allocated = Size::new(8, 2);
let clamped = constraints.clamp(allocated);
assert_eq!(clamped, Size::new(8, 2)); // Within range, unchanged

Fields

min: Size

Minimum size below which the widget is unusable or clips content.

preferred: Size

Preferred size that best displays content.

max: Option<Size>

Maximum useful size. None means unbounded (widget can use all available space).

Implementations

impl SizeConstraints

pub const ZERO: Self

Zero constraints (no minimum, no preferred, unbounded maximum).

This is the default for widgets that fill available space.

pub const fn exact(size: Size) -> Self

Create constraints with exact sizing (min = preferred = max).

Use this for widgets with a fixed, known size.

pub const fn at_least(min: Size, preferred: Size) -> Self

Create constraints with a minimum and preferred size, unbounded maximum.

pub fn clamp(&self, size: Size) -> Size

Clamp a given size to these constraints.

The result will be:

• At least min.width x min.height
• At most max.width x max.height (if max is set)

Example

use ftui_core::geometry::Size;
use ftui_widgets::SizeConstraints;

let c = SizeConstraints {
    min: Size::new(5, 2),
    preferred: Size::new(10, 5),
    max: Some(Size::new(20, 10)),
};

// Below minimum
assert_eq!(c.clamp(Size::new(3, 1)), Size::new(5, 2));

// Within range
assert_eq!(c.clamp(Size::new(15, 7)), Size::new(15, 7));

// Above maximum
assert_eq!(c.clamp(Size::new(30, 20)), Size::new(20, 10));

pub fn is_satisfied_by(&self, size: Size) -> bool

Check if these constraints are satisfied by the given size.

Returns true if size is within the min/max bounds.

pub fn intersect(&self, other: &SizeConstraints) -> SizeConstraints

Combine two constraints by taking the maximum minimums and minimum maximums.

Useful when a widget has multiple children and needs to satisfy all constraints.

Trait Implementations

impl Clone for SizeConstraints

fn clone(&self) -> SizeConstraints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SizeConstraints

impl Debug for SizeConstraints

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

Formats the value using the given formatter.

impl Default for SizeConstraints

fn default() -> Self

Returns the “default value” for a type.

impl Eq for SizeConstraints

impl Hash for SizeConstraints

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SizeConstraints

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SizeConstraints