Struct Corners 

#[repr(C)]
pub struct Corners<T: Clone + Debug + Default + PartialEq> {
    pub top_left: T,
    pub top_right: T,
    pub bottom_right: T,
    pub bottom_left: T,
}

The values at the four corners of a box, such as a border radius.

Use Corners<Pixels> for radii. Corners<Pixels> implements From<f32> and From<Pixels> for the same value at every corner.

Examples

let radii = Corners::all(px(8.));
assert_eq!(radii.top_left, Pixels::from(8.));
assert_eq!(radii.bottom_right, Pixels::from(8.));

Fields

top_left: T

The value at the top left corner.

top_right: T

The value at the top right corner.

bottom_right: T

The value at the bottom right corner.

bottom_left: T

The value at the bottom left corner.

Implementations

impl<T> Corners<T>

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

pub fn all(value: T) -> Self

Returns corners with value at every corner.

Examples

let uniform_corners = Corners::all(5.0);
assert_eq!(uniform_corners.top_left, 5.0);
assert_eq!(uniform_corners.top_right, 5.0);
assert_eq!(uniform_corners.bottom_right, 5.0);
assert_eq!(uniform_corners.bottom_left, 5.0);

pub fn corner(&self, corner: Anchor) -> T

Returns the value at corner.

The four corner anchors return their field. An edge midpoint returns the average of the two corners on that edge, computed with Half. For example, Anchor::TopCenter averages top_left and top_right.

Examples

Corner positions:

let corners = Corners {
    top_left: 10,
    top_right: 20,
    bottom_left: 30,
    bottom_right: 40
};
assert_eq!(corners.corner(Anchor::TopLeft), 10);
assert_eq!(corners.corner(Anchor::BottomRight), 40);

Edge midpoints, calculated as the average of the adjacent corners:

let corners = Corners {
    top_left: 10,
    top_right: 20,
    bottom_left: 30,
    bottom_right: 40
};
assert_eq!(corners.corner(Anchor::TopCenter), 15);
assert_eq!(corners.corner(Anchor::BottomCenter), 35);
assert_eq!(corners.corner(Anchor::LeftCenter), 20);
assert_eq!(corners.corner(Anchor::RightCenter), 30);

impl Corners<AbsoluteLength>

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

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

Examples

let corners = Corners {
    top_left: AbsoluteLength::Pixels(Pixels::from(15.0)),
    top_right: AbsoluteLength::Rems(Rems(1.0)),
    bottom_right: AbsoluteLength::Pixels(Pixels::from(30.0)),
    bottom_left: AbsoluteLength::Rems(Rems(2.0)),
};
let rem_size = Pixels::from(16.0);
let corners_in_pixels = corners.to_pixels(rem_size);

assert_eq!(corners_in_pixels.top_left, Pixels::from(15.0));
assert_eq!(corners_in_pixels.top_right, Pixels::from(16.0));
assert_eq!(corners_in_pixels.bottom_right, Pixels::from(30.0));
assert_eq!(corners_in_pixels.bottom_left, Pixels::from(32.0));

impl Corners<Pixels>

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

Multiplies each corner by factor, producing ScaledPixels.

Examples

let corners = Corners {
    top_left: Pixels::from(10.0),
    top_right: Pixels::from(20.0),
    bottom_right: Pixels::from(30.0),
    bottom_left: Pixels::from(40.0),
};
let scaled_corners = corners.scale(2.0);
assert_eq!(scaled_corners.top_left, ScaledPixels::from(20.0));
assert_eq!(scaled_corners.top_right, ScaledPixels::from(40.0));
assert_eq!(scaled_corners.bottom_right, ScaledPixels::from(60.0));
assert_eq!(scaled_corners.bottom_left, ScaledPixels::from(80.0));

pub fn max(&self) -> Pixels

Returns the largest corner value.

Examples

let corners = Corners {
    top_left: px(1.),
    top_right: px(4.),
    bottom_right: px(2.),
    bottom_left: px(3.),
};
assert_eq!(corners.max(), px(4.));

impl<T: Div<f32, Output = T> + Ord + Clone + Debug + Default + PartialEq> Corners<T>

pub fn clamp_radii_for_quad_size(self, size: Size<T>) -> Corners<T>

Limits each corner radius to half of the shorter side of size.

Radii larger than that would overlap, so each one is replaced by the limit. Radii below the limit are unchanged.

Examples

let radii = Corners::all(px(30.)).clamp_radii_for_quad_size(size(px(40.), px(100.)));
assert_eq!(radii, Corners::all(px(20.)));

let small = Corners::all(px(5.)).clamp_radii_for_quad_size(size(px(40.), px(100.)));
assert_eq!(small, Corners::all(px(5.)));

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

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

where U: Clone + Debug + Default + PartialEq,

Returns corners with f applied to each corner.

Examples

let corners = Corners {
    top_left: Pixels::from(10.0),
    top_right: Pixels::from(20.0),
    bottom_right: Pixels::from(30.0),
    bottom_left: Pixels::from(40.0),
};
let corners_in_rems = corners.map(|&px| Rems(f32::from(px) / 16.0));
assert_eq!(corners_in_rems, Corners {
    top_left: Rems(0.625),
    top_right: Rems(1.25),
    bottom_right: Rems(1.875),
    bottom_left: Rems(2.5),
});

Trait Implementations

impl<T: Clone + Clone + Debug + Default + PartialEq> Clone for Corners<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> Copy for Corners<T>

where T: Copy + Clone + Debug + Default + PartialEq,

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

impl<T: Clone + Debug + Default + PartialEq> From<CornersRefinement<T>> for Corners<T>

where Option<T>: Clone,

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

Converts to this type from the input type.

impl From<Pixels> for Corners<Pixels>

fn from(val: Pixels) -> Self

Converts to this type from the input type.

impl From<f32> for Corners<Pixels>

fn from(val: f32) -> Self

Converts to this type from the input type.

impl<T> IsZero for Corners<T>

where T: IsZero + Clone + Debug + Default + PartialEq,

fn is_zero(&self) -> bool

Returns true if this value is zero.

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

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

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

impl<T> Mul for Corners<T>

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

type Output = Corners<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, S> MulAssign<S> for Corners<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 Corners<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 Corners<T>

where Option<T>: Clone,

type Refinement = CornersRefinement<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 Corners<T>