Struct kurbo::Insets

pub struct Insets {
    pub x0: f64,
    pub y0: f64,
    pub x1: f64,
    pub y1: f64,
}

Insets from the edges of a rectangle.

The inset value for each edge can be thought of as a delta computed from the center of the rect to that edge. For instance, with an inset of 2.0 on the x-axis, a rectange with the origin (0.0, 0.0) with that inset added will have the new origin at (-2.0, 0.0).

Put alternatively, a positive inset represents increased distance from center, and a negative inset represents decreased distance from center.

Examples

Positive insets added to a Rect produce a larger Rect:

let rect = Rect::from_origin_size((0., 0.,), (10., 10.,));
let insets = Insets::uniform_xy(3., 0.,);

let inset_rect = rect + insets;
assert_eq!(inset_rect.width(), 16.0, "10.0 + 3.0 × 2");
assert_eq!(inset_rect.x0, -3.0);

Negative insets added to a Rect produce a smaller Rect:

let rect = Rect::from_origin_size((0., 0.,), (10., 10.,));
let insets = Insets::uniform_xy(-3., 0.,);

let inset_rect = rect + insets;
assert_eq!(inset_rect.width(), 4.0, "10.0 - 3.0 × 2");
assert_eq!(inset_rect.x0, 3.0);

Insets operate on the absolute rectangle Rect::abs, and so ignore existing negative widths and heights.

let rect = Rect::new(7., 11., 0., 0.,);
let insets = Insets::uniform_xy(0., 1.,);

assert_eq!(rect.width(), -7.0);

let inset_rect = rect + insets;
assert_eq!(inset_rect.width(), 7.0);
assert_eq!(inset_rect.x0, 0.0);
assert_eq!(inset_rect.height(), 13.0);

The width and height of an inset operation can still be negative if the Insets' dimensions are greater than the dimensions of the original Rect.

let rect = Rect::new(0., 0., 3., 5.);
let insets = Insets::uniform_xy(0., 7.,);

let inset_rect = rect - insets;
assert_eq!(inset_rect.height(), -9., "5 - 7 × 2")

Rect - Rect = Insets:

let rect = Rect::new(0., 0., 5., 11.);
let insets = Insets::uniform_xy(1., 7.,);

let inset_rect = rect + insets;
let insets2 = inset_rect - rect;

assert_eq!(insets2.x0, insets.x0);
assert_eq!(insets2.y1, insets.y1);
assert_eq!(insets2.x_value(), insets.x_value());
assert_eq!(insets2.y_value(), insets.y_value());

Fields

x0: f64

The minimum x coordinate (left edge).

y0: f64

The minimum y coordinate (top edge in y-down spaces).

x1: f64

The maximum x coordinate (right edge).

y1: f64

The maximum y coordinate (bottom edge in y-down spaces).

Implementations

impl Insets

pub const ZERO: Insets

Zero'd insets.

pub const fn uniform(d: f64) -> Insets

New uniform insets.

pub const fn uniform_xy(x: f64, y: f64) -> Insets

New insets with uniform values along each axis.

pub const fn new(x0: f64, y0: f64, x1: f64, y1: f64) -> Insets

New insets. The ordering of the arguments is "left, top, right, bottom", assuming a y-down coordinate space.

pub fn x_value(self) -> f64

The total delta on the x-axis represented by these insets.

Examples

use kurbo::Insets;

let insets = Insets::uniform_xy(3., 8.);
assert_eq!(insets.x_value(), 6.);

let insets = Insets::new(5., 0., -12., 0.,);
assert_eq!(insets.x_value(), -7.);

pub fn y_value(self) -> f64

The total delta on the y-axis represented by these insets.

Examples

use kurbo::Insets;

let insets = Insets::uniform_xy(3., 7.);
assert_eq!(insets.y_value(), 14.);

let insets = Insets::new(5., 10., -12., 4.,);
assert_eq!(insets.y_value(), 14.);

pub fn size(self) -> Size

Returns the total delta represented by these insets as a Size.

This is equivalent to creating a Size from the values returned by x_value and y_value.

This function may return a a size with negative values.

Examples

use kurbo::{Insets, Size};

let insets = Insets::new(11.1, -43.3, 3.333, -0.0);
assert_eq!(insets.size(), Size::new(insets.x_value(), insets.y_value()));

pub fn are_nonnegative(self) -> bool

Return true iff all values are nonnegative.

pub fn nonnegative(self) -> Insets

Return new Insets with all negative values replaced with 0.0.

This is provided as a convenience for applications where negative insets are not meaningful.

Examples

use kurbo::Insets;

let insets = Insets::new(-10., 3., -0.2, 4.);
let nonnegative = insets.nonnegative();
assert_eq!(nonnegative.x_value(), 0.0);
assert_eq!(nonnegative.y_value(), 7.0);

Trait Implementations

impl Add<Insets> for Rect

type Output = Rect

The resulting type after applying the + operator.

fn add(self, other: Insets) -> Rect

Performs the + operation.

impl Add<Rect> for Insets

type Output = Rect

The resulting type after applying the + operator.

fn add(self, other: Rect) -> Rect

Performs the + operation.

impl Clone for Insets

fn clone(&self) -> Insets

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Insets

impl Debug for Insets

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

Formats the value using the given formatter.

impl Default for Insets

fn default() -> Insets

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Insets

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<(f64, f64, f64, f64)> for Insets

fn from(src: (f64, f64, f64, f64)) -> Insets

Performs the conversion.

impl From<(f64, f64)> for Insets

fn from(src: (f64, f64)) -> Insets

Performs the conversion.

impl From<f64> for Insets

fn from(src: f64) -> Insets

Performs the conversion.

impl Neg for Insets

type Output = Insets

The resulting type after applying the - operator.

fn neg(self) -> Insets

Performs the unary - operation.

impl PartialEq<Insets> for Insets

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Insets

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Insets

impl Sub<Insets> for Rect

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, other: Insets) -> Rect

Performs the - operation.

impl Sub<Rect> for Insets

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, other: Rect) -> Rect

Performs the - operation.