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: 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: Corner) -> T

Returns the requested corner.

Returns

A Point<T> representing the corner requested by the parameter.

Examples

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

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

Corner 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>