Struct BoxConstraints 

pub struct BoxConstraints {
    pub min_w: f32,
    pub max_w: f32,
    pub min_h: f32,
    pub max_h: f32,
}

Minimum and maximum width/height bounds passed from parent to child during layout.

BoxConstraints is the fundamental mechanism for top-down size negotiation. A parent creates constraints describing the space available to a child, and the child returns a LayoutSize that satisfies those constraints.

There are two common patterns:

• Tight constraints – min == max, forcing the child to a specific size. Created with BoxConstraints::tight.
• Loose constraints – min == 0, giving the child freedom to be smaller than the max. Created with BoxConstraints::loose.

Example

use fission_layout::{BoxConstraints, LayoutSize};

let constraints = BoxConstraints::loose(800.0, 600.0);
assert_eq!(constraints.min_w, 0.0);

let child_wants = LayoutSize::new(300.0, 200.0);
let actual = constraints.constrain(child_wants);
assert_eq!(actual, child_wants); // fits within the constraints

Fields

min_w: f32

Minimum width the child must occupy.

max_w: f32

Maximum width the child may occupy. Can be f32::INFINITY for unbounded.

min_h: f32

Minimum height the child must occupy.

max_h: f32

Maximum height the child may occupy. Can be f32::INFINITY for unbounded.

Implementations

impl BoxConstraints

pub fn tight(size: LayoutSize) -> BoxConstraints

Creates tight constraints that force a child to exactly size.

Both min and max are set to the given width/height.

pub fn loose(max_w: f32, max_h: f32) -> BoxConstraints

Creates loose constraints: min is zero, max is the given values.

The child can be anywhere from zero to max_w x max_h.

pub fn is_width_bounded(&self) -> bool

Returns true if the maximum width is finite (not f32::INFINITY).

pub fn is_height_bounded(&self) -> bool

Returns true if the maximum height is finite (not f32::INFINITY).

pub fn constrain(&self, size: LayoutSize) -> LayoutSize

Clamps size so it falls within these constraints.

The returned width is max(min_w, min(size.width, max_w)), and likewise for height.

pub fn smallest(&self) -> LayoutSize

Returns the smallest size that satisfies these constraints: (min_w, min_h).

pub fn deflate(&self, padding: [f32; 4]) -> BoxConstraints

Returns new constraints shrunk inward by padding.

Padding is [left, right, top, bottom]. Horizontal padding reduces the width bounds; vertical padding reduces the height bounds. Bounds are clamped to zero.

pub fn tighten(&self, width: Option<f32>, height: Option<f32>) -> BoxConstraints

Makes the constraints tighter by fixing the width and/or height.

If width is Some, both min_w and max_w are set to that value (clamped to the current bounds). Same for height.

pub fn apply_min_max( &self, min_w: Option<f32>, max_w: Option<f32>, min_h: Option<f32>, max_h: Option<f32>, ) -> BoxConstraints

Applies additional min/max constraints on top of the current ones.

Each Some value further restricts the corresponding bound. None values leave the bound unchanged. After adjustment, max is clamped to be at least min.

pub fn loosen(&self) -> BoxConstraints

Returns loose constraints with the same maximums but zeroed minimums.

Useful when a parent wants to let a child be as small as it likes while still capping its maximum size.

Trait Implementations

impl Clone for BoxConstraints

fn clone(&self) -> BoxConstraints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoxConstraints

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

Formats the value using the given formatter.

impl PartialEq for BoxConstraints

fn eq(&self, other: &BoxConstraints) -> 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 Copy for BoxConstraints

impl StructuralPartialEq for BoxConstraints