Struct 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.

Note that these constraints define the child inner bounds (the visual size) only, using the child size call layout to get the child outer bounds size.

pub fn child_offset( self, child_size: PxSize, parent_size: PxSize, direction: LayoutDirection, ) -> PxVector

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

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

pub fn measure( self, child_size: PxSize, parent_constraints: PxConstraints2d, ) -> PxSize

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

Note that the child must be measured using child_constraints, the child_size is the size the child will be rendered at, this method computes the child outer bounds.

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.

See measure for more details.

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.

See measure for more details.

pub fn layout( self, child_size: PxSize, parent_constraints: PxConstraints2d, direction: LayoutDirection, ) -> (PxSize, PxVector, bool)

Compute the outer size and inner offset.

Note that the child must be layout using the child_constraints, the child_size is the size the child will be rendered at, this method computes the child outer bounds.

Returns the outer size, inner offset and is_baseline

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

Returns the named alignment.

Trait Implementations

impl Clone for Align

fn clone(&self) -> Align

Returns a duplicate 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

Formats the value using the given formatter.

impl Default for Align

fn default() -> Self

Align::START.

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

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Align

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

Formats the value using the given formatter.

impl<S: Into<Factor2d>> Div<S> for Align

type Output = Align

The resulting type after applying the / operator.

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

Performs the / operation.

impl<S: Into<Factor2d>> DivAssign<S> for Align

fn div_assign(&mut self, rhs: S)

Performs the /= operation.

impl<X: Into<Factor>, Y: Into<Factor>> From<(X, Y)> for Align

fn from((x, y): (X, Y)) -> Self

Converts to this type from the input type.

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

fn from((x, rtl, y): (X, bool, Y)) -> Self

Converts to this type from the input type.

impl From<Align> for Point

fn from(alignment: Align) -> Self

To relative length x and y.

impl From<Factor> for Align

fn from(xy: Factor) -> Self

Converts to this type from the input type.

impl From<Factor2d> for Align

fn from(factor2d: Factor2d) -> Self

Converts to this type from the input type.

impl From<FactorPercent> for Align

fn from(xy: FactorPercent) -> Self

Converts to this type from the input type.

impl FromStr for Align

Parse a named align or "(x, y)" were x Factor or "FILL" and y is factor, "FILL" or "BASELINE".

type Err = ParseFloatCompositeError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Align

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

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<X: Into<Factor>, Y: Into<Factor>> IntoVar<Align> for (X, Y)

fn into_var(self) -> Var<Align>

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

fn into_var(self) -> Var<Align>

impl IntoVar<Align> for Factor

fn into_var(self) -> Var<Align>

impl IntoVar<Align> for Factor2d

fn into_var(self) -> Var<Align>

impl IntoVar<Align> for FactorPercent

fn into_var(self) -> Var<Align>

impl IntoVar<Point> for Align

fn into_var(self) -> Var<Point>

To relative length x and y.

impl<S: Into<Factor2d>> Mul<S> for Align

type Output = Align

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: Into<Factor2d>> MulAssign<S> for Align

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::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Transitionable for Align

fn lerp(self, to: &Self, step: EasingStep) -> Self

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

impl Copy for Align

impl Eq for Align

impl<X: Into<Factor>, Y: Into<Factor>> IntoValue<Align> for (X, Y)

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

impl IntoValue<Align> for Factor

impl IntoValue<Align> for Factor2d

impl IntoValue<Align> for FactorPercent

impl IntoValue<Point> for Align

impl StructuralPartialEq for Align