Struct Regions

pub struct Regions<'a> {
    pub size: Size,
    pub expand: Axes<bool>,
    pub full: Abs,
    pub backlog: &'a [Abs],
    pub last: Option<Abs>,
}

A sequence of regions to layout into.

A region is a contiguous rectangular space in which elements can be laid out. All regions within a Regions object have the same width, namely self.size.x. This means that it is not currently possible to, for instance, have content wrap to the side of a floating element.

Fields

size: Size

The remaining size of the first region.

expand: Axes<bool>

Whether elements should expand to fill the regions instead of shrinking to fit the content.

full: Abs

The full height of the region for relative sizing.

backlog: &'a [Abs]

The height of followup regions. The width is the same for all regions.

last: Option<Abs>

The height of the final region that is repeated once the backlog is drained. The width is the same for all regions.

Implementations

impl Regions<'_>

pub fn repeat(size: Size, expand: Axes<bool>) -> Self

Create a new sequence of same-size regions that repeats indefinitely.

pub fn base(&self) -> Size

The base size, which doesn’t take into account that the regions is already partially used up.

This is also used for relative sizing.

pub fn map<'v, F>(&self, backlog: &'v mut Vec<Abs>, f: F) -> Regions<'v>

where F: FnMut(Size) -> Size,

Create new regions where all sizes are mapped with f.

Note that since all regions must have the same width, the width returned by f is ignored for the backlog and the final region.

pub fn is_full(&self) -> bool

Whether the first region is full and a region break is called for.

pub fn may_break(&self) -> bool

Whether a region break is permitted.

pub fn may_progress(&self) -> bool

Whether calling next() may improve a situation where there is a lack of space.

pub fn next(&mut self)

Advance to the next region if there is any.

pub fn iter(&self) -> impl Iterator<Item = Size> + '_

An iterator that returns the sizes of the first and all following regions, equivalently to what would be produced by calling next() repeatedly until all regions are exhausted. This iterator may be infinite.

Trait Implementations

impl<'a> Clone for Regions<'a>

fn clone(&self) -> Regions<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Regions<'_>

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

Formats the value using the given formatter.

impl From<Region> for Regions<'_>

fn from(region: Region) -> Self

Converts to this type from the input type.

impl<'a> Hash for Regions<'a>

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<'a> Copy for Regions<'a>