Enum Align

pub enum Align {
    Min,
    Center,
    Max,
}

left/center/right or top/center/bottom alignment for e.g. anchors and layouts.

Variants

Min

Left or top.

Center

Horizontal or vertical center.

Max

Right or bottom.

Implementations

impl Align

pub const LEFT: Align = Self::Min

Convenience for Self::Min

pub const RIGHT: Align = Self::Max

Convenience for Self::Max

pub const TOP: Align = Self::Min

Convenience for Self::Min

pub const BOTTOM: Align = Self::Max

Convenience for Self::Max

pub fn to_factor(self) -> f32

Convert Min => 0.0, Center => 0.5 or Max => 1.0.

pub fn to_sign(self) -> f32

Convert Min => -1.0, Center => 0.0 or Max => 1.0.

pub fn align_size_within_range( self, size: f32, range: impl Into<Rangef>, ) -> Rangef

Returns a range of given size within a specified range.

If the requested size is bigger than the size of range, then the returned range will not fit into the available range. The extra space will be allocated from:

Align	Side
Min	right (end)
Center	both
Max	left (start)

Examples

use std::f32::{INFINITY, NEG_INFINITY};
use emath::Align::*;

// The size is smaller than a range
assert_eq!(Min   .align_size_within_range(2.0, 10.0..=20.0), 10.0..=12.0);
assert_eq!(Center.align_size_within_range(2.0, 10.0..=20.0), 14.0..=16.0);
assert_eq!(Max   .align_size_within_range(2.0, 10.0..=20.0), 18.0..=20.0);

// The size is bigger than a range
assert_eq!(Min   .align_size_within_range(20.0, 10.0..=20.0), 10.0..=30.0);
assert_eq!(Center.align_size_within_range(20.0, 10.0..=20.0),  5.0..=25.0);
assert_eq!(Max   .align_size_within_range(20.0, 10.0..=20.0),  0.0..=20.0);

// The size is infinity, but range is finite - a special case of a previous example
assert_eq!(Min   .align_size_within_range(INFINITY, 10.0..=20.0),         10.0..=INFINITY);
assert_eq!(Center.align_size_within_range(INFINITY, 10.0..=20.0), NEG_INFINITY..=INFINITY);
assert_eq!(Max   .align_size_within_range(INFINITY, 10.0..=20.0), NEG_INFINITY..=20.0);

The infinity-sized ranges can produce a surprising results, if the size is also infinity, use such ranges with carefully!

use std::f32::{INFINITY, NEG_INFINITY};
use emath::Align::*;

// Allocating a size aligned for infinity bound will lead to empty ranges!
assert_eq!(Min   .align_size_within_range(2.0, 10.0..=INFINITY),     10.0..=12.0);
assert_eq!(Center.align_size_within_range(2.0, 10.0..=INFINITY), INFINITY..=INFINITY);// (!)
assert_eq!(Max   .align_size_within_range(2.0, 10.0..=INFINITY), INFINITY..=INFINITY);// (!)

assert_eq!(Min   .align_size_within_range(2.0, NEG_INFINITY..=20.0), NEG_INFINITY..=NEG_INFINITY);// (!)
assert_eq!(Center.align_size_within_range(2.0, NEG_INFINITY..=20.0), NEG_INFINITY..=NEG_INFINITY);// (!)
assert_eq!(Max   .align_size_within_range(2.0, NEG_INFINITY..=20.0),         18.0..=20.0);


// The infinity size will always return the given range if it has at least one infinity bound
assert_eq!(Min   .align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
assert_eq!(Center.align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);
assert_eq!(Max   .align_size_within_range(INFINITY, 10.0..=INFINITY), 10.0..=INFINITY);

assert_eq!(Min   .align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
assert_eq!(Center.align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);
assert_eq!(Max   .align_size_within_range(INFINITY, NEG_INFINITY..=20.0), NEG_INFINITY..=20.0);

Trait Implementations

impl Clone for Align

fn clone(&self) -> Align

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Align

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

Formats the value using the given formatter.

impl Default for Align

fn default() -> Align

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Align

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Align

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Align

fn eq(&self, other: &Align) -> 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 Serialize for Align

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Align

impl Eq for Align

impl StructuralPartialEq for Align