Struct Edges 

#[repr(C)]
pub struct Edges<T: Clone + Debug + Default + PartialEq> {
    pub top: T,
    pub right: T,
    pub bottom: T,
    pub left: T,
}

The sizes of the four sides of a box, such as its padding or margin.

Each field holds the size of one side. The value is measured inward from that side: top is the space along the top edge, and so on. Edges<Pixels> implements From<f32> and From<Pixels> for the same value on all four sides.

Examples

let edges = Edges {
    top: 10.0,
    right: 20.0,
    bottom: 30.0,
    left: 40.0,
};

assert_eq!(edges.top, 10.0);
assert_eq!(edges.right, 20.0);
assert_eq!(edges.bottom, 30.0);
assert_eq!(edges.left, 40.0);

Fields

top: T

The size of the top side.

right: T

The size of the right side.

bottom: T

The size of the bottom side.

left: T

The size of the left side.

Implementations

impl<T: Clone + Debug + Default + PartialEq> Edges<T>

pub fn all(value: T) -> Self

Returns edges with value on all four sides.

Examples

let uniform_edges = Edges::all(10.0);
assert_eq!(uniform_edges.top, 10.0);
assert_eq!(uniform_edges.right, 10.0);
assert_eq!(uniform_edges.bottom, 10.0);
assert_eq!(uniform_edges.left, 10.0);

pub fn horizontal(value: T) -> Self

Returns edges with value on the left and right sides, and the default on the top and bottom.

Examples

let edges = Edges::horizontal(10.0);
assert_eq!(edges.top, 0.0);
assert_eq!(edges.right, 10.0);
assert_eq!(edges.bottom, 0.0);
assert_eq!(edges.left, 10.0);

pub fn vertical(value: T) -> Self

Returns edges with value on the top and bottom sides, and the default on the left and right.

Examples

let edges = Edges::vertical(10.0);
assert_eq!(edges.top, 10.0);
assert_eq!(edges.right, 0.0);
assert_eq!(edges.bottom, 10.0);
assert_eq!(edges.left, 0.0);

pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Edges<U>

where U: Clone + Debug + Default + PartialEq,

Returns edges with f applied to each side.

Examples

let edges = Edges { top: 10, right: 20, bottom: 30, left: 40 };
let edges_float = edges.map(|&value| value as f32 * 1.1);
assert_eq!(edges_float, Edges { top: 11.0, right: 22.0, bottom: 33.0, left: 44.0 });

pub fn any<F: Fn(&T) -> bool>(&self, predicate: F) -> bool

Returns true if predicate is true for at least one side.

Examples

let edges = Edges {
    top: 10,
    right: 0,
    bottom: 5,
    left: 0,
};

assert!(edges.any(|value| *value == 0));
assert!(edges.any(|value| *value > 0));
assert!(!edges.any(|value| *value > 10));

impl Edges<Length>

pub fn auto() -> Self

Returns edges with Length::Auto on all four sides.

Examples

let auto_edges = Edges::auto();
assert_eq!(auto_edges.top, Length::Auto);
assert_eq!(auto_edges.right, Length::Auto);
assert_eq!(auto_edges.bottom, Length::Auto);
assert_eq!(auto_edges.left, Length::Auto);

pub fn zero() -> Self

Returns edges of zero pixels on all four sides.

Examples

let no_edges = Edges::<Length>::zero();
assert_eq!(no_edges.top, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
assert_eq!(no_edges.right, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
assert_eq!(no_edges.bottom, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
assert_eq!(no_edges.left, Length::Definite(DefiniteLength::from(Pixels::ZERO)));

impl Edges<DefiniteLength>

pub fn zero() -> Self

Returns edges of zero on all four sides.

Examples

let no_edges = Edges::<DefiniteLength>::zero();
assert_eq!(no_edges.top, DefiniteLength::from(px(0.)));
assert_eq!(no_edges.right, DefiniteLength::from(px(0.)));
assert_eq!(no_edges.bottom, DefiniteLength::from(px(0.)));
assert_eq!(no_edges.left, DefiniteLength::from(px(0.)));

pub fn to_pixels( self, parent_size: Size<AbsoluteLength>, rem_size: Pixels, ) -> Edges<Pixels>

Resolves each side to pixels.

top and bottom are fractions of parent_size.height, and left and right are fractions of parent_size.width. Rems are multiplied by rem_size.

Examples

let edges = Edges {
    top: DefiniteLength::Absolute(AbsoluteLength::Pixels(px(10.0))),
    right: relative(0.5).into(),
    bottom: DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0))),
    left: relative(0.25).into(),
};
let parent_size = Size {
    width: AbsoluteLength::Pixels(px(200.0)),
    height: AbsoluteLength::Pixels(px(100.0)),
};
let rem_size = px(16.0);
let edges_in_pixels = edges.to_pixels(parent_size, rem_size);

assert_eq!(edges_in_pixels.top, px(10.0));
assert_eq!(edges_in_pixels.right, px(100.0));
assert_eq!(edges_in_pixels.bottom, px(32.0));
assert_eq!(edges_in_pixels.left, px(50.0));

impl Edges<AbsoluteLength>

pub fn zero() -> Self

Sets the edges of the Edges struct to zero, which means no size or thickness.

This is typically used when you want to specify that a box (like a padding or margin area) should have no edges, effectively making it non-existent or invisible in layout calculations.

Returns

Returns an Edges<AbsoluteLength> with all edges set to zero length.

Examples

let no_edges = Edges::<AbsoluteLength>::zero();
assert_eq!(no_edges.top, AbsoluteLength::Pixels(Pixels::ZERO));
assert_eq!(no_edges.right, AbsoluteLength::Pixels(Pixels::ZERO));
assert_eq!(no_edges.bottom, AbsoluteLength::Pixels(Pixels::ZERO));
assert_eq!(no_edges.left, AbsoluteLength::Pixels(Pixels::ZERO));

pub fn to_pixels(self, rem_size: Pixels) -> Edges<Pixels>

Resolves each side to pixels. Rems are multiplied by rem_size.

Examples

let edges = Edges {
    top: AbsoluteLength::Pixels(px(10.0)),
    right: AbsoluteLength::Rems(rems(1.0)),
    bottom: AbsoluteLength::Pixels(px(20.0)),
    left: AbsoluteLength::Rems(rems(2.0)),
};
let rem_size = px(16.0);
let edges_in_pixels = edges.to_pixels(rem_size);

assert_eq!(edges_in_pixels.top, px(10.0));
assert_eq!(edges_in_pixels.right, px(16.0));
assert_eq!(edges_in_pixels.bottom, px(20.0));
assert_eq!(edges_in_pixels.left, px(32.0));

impl Edges<Pixels>

pub fn scale(&self, factor: f32) -> Edges<ScaledPixels>

Multiplies each side by factor, producing ScaledPixels.

Examples

let edges = Edges {
    top: Pixels::from(10.0),
    right: Pixels::from(20.0),
    bottom: Pixels::from(30.0),
    left: Pixels::from(40.0),
};
let scaled_edges = edges.scale(2.0);
assert_eq!(scaled_edges.top, ScaledPixels::from(20.0));
assert_eq!(scaled_edges.right, ScaledPixels::from(40.0));
assert_eq!(scaled_edges.bottom, ScaledPixels::from(60.0));
assert_eq!(scaled_edges.left, ScaledPixels::from(80.0));

pub fn max(&self) -> Pixels

Returns the largest of the four sides.

Examples

let edges = Edges { top: px(4.), right: px(9.), bottom: px(2.), left: px(1.) };
assert_eq!(edges.max(), px(9.));

Trait Implementations

impl<T: Clone + Clone + Debug + Default + PartialEq> Clone for Edges<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + Debug + Default + PartialEq + Copy> Copy for Edges<T>

impl<T: Debug + Clone + Debug + Default + PartialEq> Debug for Edges<T>

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

Formats the value using the given formatter.

impl<T: Default + Clone + Debug + Default + PartialEq> Default for Edges<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Eq + Clone + Debug + Default + PartialEq> Eq for Edges<T>

impl<T: Clone + Debug + Default + PartialEq> From<EdgesRefinement<T>> for Edges<T>

where Option<T>: Clone,

fn from(value: EdgesRefinement<T>) -> Self

Converts to this type from the input type.

impl From<Pixels> for Edges<Pixels>

fn from(val: Pixels) -> Self

Converts to this type from the input type.

impl From<f32> for Edges<Pixels>

fn from(val: f32) -> Self

Converts to this type from the input type.

impl<T: Lerp + Clone + Debug + Default + PartialEq> Lerp for Edges<T>

fn lerp(&self, to: &Self, delta: f32) -> Self

Returns the value delta of the way from self to to.

impl<T> Mul for Edges<T>

where T: Mul<Output = T> + Clone + Debug + Default + PartialEq,

type Output = Edges<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T, S> MulAssign<S> for Edges<T>

where T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq, S: Clone,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl<T: PartialEq + Clone + Debug + Default + PartialEq> PartialEq for Edges<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: Clone + Debug + Default + PartialEq> Refineable for Edges<T>

where Option<T>: Clone,

type Refinement = EdgesRefinement<T>

fn refine(&mut self, refinement: &Self::Refinement)

Applies the given refinement to this instance, modifying it in place.

fn refined(self, refinement: Self::Refinement) -> Self

Returns a new instance with the refinement applied, equivalent to cloning self and calling refine on it.

fn is_superset_of(&self, refinement: &Self::Refinement) -> bool

Returns true if this instance would contain all values from the refinement.

fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement

Returns a refinement that represents the difference between this instance and the given refinement.

fn from_cascade(cascade: &Cascade<Self>) -> Self

where Self: Sized + Default,

Creates an instance from a cascade by merging all refinements atop the default value.

impl<T: PartialEq + Clone + Debug + Default + PartialEq> StructuralPartialEq for Edges<T>