Struct zng::layout::Align

pub struct Align {
    pub x: Factor,
    pub x_rtl_aware: bool,
    pub y: Factor,
}

x and y alignment.

The values indicate how much to the right and bottom the content is moved within a larger available space. An x value of 0.0 means the content left border touches the container left border, a value of 1.0 means the content right border touches the container right border.

There is a constant for each of the usual alignment values, the alignment is defined as two factors like this primarily for animating transition between alignments.

Values outside of the [0.0..=1.0] range places the content outside of the container bounds.

Special Values

The f32::INFINITY value can be used in x or y to indicate that the content must fill the available space.

The f32::NEG_INFINITY value can be used in y to indicate that a panel widget must align its items by each baseline, for most widgets this is the same as BOTTOM, but for texts this aligns to the baseline of the texts (bottom + baseline).

You can use the is_fill_x, is_fill_y and is_baseline methods to probe for these special values.

Right-to-Left

The x alignment can be flagged as x_rtl_aware, in widgets that implement right-to-left the x value is flipped around 0.5.fct(). The named const values that contain START and END are x_rtl_aware, the others are not. The x_rtl_aware flag is sticky, all arithmetic operations between aligns output an x_rtl_aware align if any of the inputs is flagged. The flag is only resolved explicitly, arithmetic operations apply on the

Fields

x: Factor

x alignment in a [0.0..=1.0] range.

x_rtl_aware: bool

If x is flipped (around 0.5) in right-to-left contexts.

y: Factor

y alignment in a [0.0..=1.0] range.

Implementations

impl Align

pub fn x(self, direction: LayoutDirection) -> Factor

Gets the best finite x align value.

Replaces FILL with START, flips x for right-to-left if applicable.

pub fn y(self) -> Factor

Gets the best finite y align value.

Returns 1.fct() for is_baseline, implementers must add the baseline offset to that.

pub fn xy(self, direction: LayoutDirection) -> Factor2d

Gets the best finite x and y align values.

pub fn is_fill_x(self) -> bool

Returns true if x is a special value that indicates the content width must be the container width.

pub fn is_fill_y(self) -> bool

Returns true if y is a special value that indicates the content height must be the container height.

pub fn is_baseline(self) -> bool

Returns true if y is a special value that indicates the contents must be aligned by their baseline.

If this is true the y alignment must be BOTTOM plus the baseline offset.

pub fn fill_vector(self) -> BoolVector2D

Returns a boolean vector of the fill values.

pub fn child_constraints( self, parent_constraints: PxConstraints2d, ) -> PxConstraints2d

Constraints that must be used to layout a child node with the alignment.

pub fn child_offset( self, child_size: Size2D<Px, Px>, parent_size: Size2D<Px, Px>, direction: LayoutDirection, ) -> Vector2D<Px, Px>

Compute the offset for a given child size, parent size and layout direction.

Note that this does not flag baseline offset, you can use Align::layout to cover all corner cases.

pub fn measure( self, child_size: Size2D<Px, Px>, parent_constraints: PxConstraints2d, ) -> Size2D<Px, Px>

Computes the size returned by layout for the given child size and constraints.

pub fn measure_x( self, child_width: Px, parent_constraints_x: PxConstraints, ) -> Px

Computes the width returned by layout for the given child width and x constraints.

pub fn measure_y( self, child_height: Px, parent_constraints_y: PxConstraints, ) -> Px

Computes the height returned by layout for the given child height and y constraints.

pub fn layout( self, child_size: Size2D<Px, Px>, parent_constraints: PxConstraints2d, direction: LayoutDirection, ) -> (Size2D<Px, Px>, Vector2D<Px, Px>, bool)

Applies the alignment transform to wl and returns the size of the parent align node, the translate offset and if baseline must be translated.

impl Align

pub const TOP_START: Align = _

(0.0, 0.0)

pub const TOP_LEFT: Align = _

(0.0, 0.0)

pub const BOTTOM_START: Align = _

(0.0, 1.0)

pub const BOTTOM_LEFT: Align = _

(0.0, 1.0)

pub const TOP_END: Align = _

(1.0, 0.0)

pub const TOP_RIGHT: Align = _

(1.0, 0.0)

pub const BOTTOM_END: Align = _

(1.0, 1.0)

pub const BOTTOM_RIGHT: Align = _

(1.0, 1.0)

pub const START: Align = _

(0.0, 0.5)

pub const LEFT: Align = _

(0.0, 0.5)

pub const END: Align = _

(1.0, 0.5)

pub const RIGHT: Align = _

(1.0, 0.5)

pub const TOP: Align = _

(0.5, 0.0)

pub const BOTTOM: Align = _

(0.5, 1.0)

pub const CENTER: Align = _

(0.5, 0.5)

pub const FILL_TOP: Align = _

(f32::INFINITY, 0.0)

pub const FILL_BOTTOM: Align = _

(f32::INFINITY, 1.0)

pub const FILL_START: Align = _

(0.0, f32::INFINITY)

pub const FILL_LEFT: Align = _

(0.0, f32::INFINITY)

pub const FILL_RIGHT: Align = _

(1.0, f32::INFINITY)

pub const FILL_END: Align = _

(1.0, f32::INFINITY)

pub const FILL_X: Align = _

(f32::INFINITY, 0.5)

pub const FILL_Y: Align = _

(0.5, f32::INFINITY)

pub const FILL: Align = _

(f32::INFINITY, f32::INFINITY)

pub const BASELINE_START: Align = _

(0.0, f32::NEG_INFINITY)

pub const BASELINE_LEFT: Align = _

(0.0, f32::NEG_INFINITY)

pub const BASELINE_CENTER: Align = _

(0.5, f32::NEG_INFINITY)

pub const BASELINE_END: Align = _

(1.0, f32::NEG_INFINITY)

pub const BASELINE_RIGHT: Align = _

(1.0, f32::NEG_INFINITY)

pub const BASELINE: Align = _

(f32::INFINITY, f32::NEG_INFINITY)

pub fn name(self) -> Option<&'static str>

Returns the alignment const name if self is equal to one of then.

pub fn from_name(name: &str) -> Option<Align>

Returns the named alignment.

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

Align::START.

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 Display for Align

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

Formats the value using the given formatter.

impl<S> Div<S> for Align

where S: Into<Factor2d>,

type Output = Align

The resulting type after applying the / operator.

fn div(self, rhs: S) -> Align

Performs the / operation.

impl<S> DivAssign<S> for Align

where S: Into<Factor2d>,

fn div_assign(&mut self, rhs: S)

Performs the /= operation.

impl<X, Y> From<(X, Y)> for Align

where X: Into<Factor>, Y: Into<Factor>,

fn from(_: (X, Y)) -> Align

Converts to this type from the input type.

impl<X, Y> From<(X, bool, Y)> for Align

where X: Into<Factor>, Y: Into<Factor>,

fn from(_: (X, bool, Y)) -> Align

Converts to this type from the input type.

impl From<Align> for Point

fn from(alignment: Align) -> Point

To relative length x and y.

impl From<Factor> for Align

fn from(xy: Factor) -> Align

Converts to this type from the input type.

impl From<Factor2d> for Align

fn from(factor2d: Factor2d) -> Align

Converts to this type from the input type.

impl From<FactorPercent> for Align

fn from(xy: FactorPercent) -> Align

Converts to this type from the input type.

impl<X, Y> IntoVar<Align> for (X, Y)

where X: Into<Factor>, Y: Into<Factor>,

type Var = LocalVar<Align>

Variable type that will wrap the T value.

fn into_var(self) -> <(X, Y) as IntoVar<Align>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl<X, Y> IntoVar<Align> for (X, bool, Y)

where X: Into<Factor>, Y: Into<Factor>,

type Var = LocalVar<Align>

Variable type that will wrap the T value.

fn into_var(self) -> <(X, bool, Y) as IntoVar<Align>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Align> for Factor

type Var = LocalVar<Align>

Variable type that will wrap the T value.

fn into_var(self) -> <Factor as IntoVar<Align>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Align> for Factor2d

type Var = LocalVar<Align>

Variable type that will wrap the T value.

fn into_var(self) -> <Factor2d as IntoVar<Align>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Align> for FactorPercent

type Var = LocalVar<Align>

Variable type that will wrap the T value.

fn into_var(self) -> <FactorPercent as IntoVar<Align>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl IntoVar<Point> for Align

fn into_var(self) -> <Align as IntoVar<Point>>::Var

To relative length x and y.

type Var = LocalVar<Point>

Variable type that will wrap the T value.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl<S> Mul<S> for Align

where S: Into<Factor2d>,

type Output = Align

The resulting type after applying the * operator.

fn mul(self, rhs: S) -> Align

Performs the * operation.

impl<S> MulAssign<S> for Align

where S: Into<Factor2d>,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

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 Transitionable for Align

fn lerp(self, to: &Align, step: Factor) -> Align

Sample the linear interpolation from self -> to by step.

impl Copy for Align

impl<X, Y> IntoValue<Align> for (X, Y)

where X: Into<Factor>, Y: Into<Factor>,

impl<X, Y> IntoValue<Align> for (X, bool, Y)

where X: Into<Factor>, Y: Into<Factor>,

impl IntoValue<Align> for Factor

impl IntoValue<Align> for Factor2d

impl IntoValue<Align> for FactorPercent

impl IntoValue<Point> for Align