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,
}

Represents the corners of a box in a 2D space, such as border radius.

Each field represents the size of the corner on one side of the box: top_left, top_right, bottom_right, and bottom_left.

Fields

top_left: T

The value associated with the top left corner.

top_right: T

The value associated with the top right corner.

bottom_right: T

The value associated with the bottom right corner.

bottom_left: T

The value associated with 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

Constructs Corners where all sides are set to the same specified value.

This function creates a Corners instance with the top_left, top_right, bottom_right, and bottom_left fields all initialized to the same value provided as an argument. This is useful when you want to have uniform corners around a box, such as a uniform border radius on a rectangle.

Arguments

• value - The value to set for all four corners.

Returns

An Corners instance with all corners set to the given value.

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 requested corner value, supporting all eight corner positions.

For the four basic corners (TopLeft, TopRight, BottomLeft, BottomRight), this returns the corresponding field value directly.

For the center positions (TopCenter, BottomCenter, LeftCenter, RightCenter), this calculates the average of the two adjacent corners.

Returns

A value of type T representing the corner requested by the parameter.

Examples

Basic 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);

Center positions (calculated as average of 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>

Converts the AbsoluteLength to Pixels based on the provided rem size.

Arguments

• rem_size - The size of one REM unit in pixels, used for conversion if the AbsoluteLength is in REMs.

Returns

Returns a Corners<Pixels> instance with each corner’s length converted to pixels.

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)); // 1 rem converted to pixels
assert_eq!(corners_in_pixels.bottom_right, Pixels::from(30.0));
assert_eq!(corners_in_pixels.bottom_left, Pixels::from(32.0)); // 2 rems converted to pixels

impl Corners<Pixels>

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

Scales the Corners<Pixels> by a given factor, returning Corners<ScaledPixels>.

This method is typically used for adjusting the corner sizes for different display densities or scaling factors.

Arguments

• factor - The scaling factor to apply to each corner.

Returns

Returns a new Corners<ScaledPixels> where each corner is the result of scaling the original corner by the given factor.

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 maximum value of any corner.

Returns

The maximum Pixels value among all four corners.

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>

Clamps corner radii to be less than or equal to half the shortest side of a quad.

Arguments

• size - The size of the quad which limits the size of the corner radii.

Returns

Anchor radii values clamped to fit.

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,

Applies a function to each field of the Corners, producing a new Corners<U>.

This method allows for converting a Corners<T> to a Corners<U> by specifying a closure that defines how to convert between the two types. The closure is applied to each field (top_left, top_right, bottom_right, bottom_left), resulting in new corners of the desired type.

Arguments

• f - A closure that takes a reference to a value of type T and returns a value of type U.

Returns

Returns a new Corners<U> with each field mapped by the provided function.

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) -> Corners<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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() -> Corners<T>

Returns the “default value” for a type.

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

Determines if the value is zero.

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: &Corners<T>) -> 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<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> Copy for Corners<T>

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

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

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