Struct zng::stack::StackDirection

pub struct StackDirection {
    pub place: Point,
    pub origin: Point,
    pub is_rtl_aware: bool,
}

Defines a placement point in the previous item and the origin point of the next.

Defining stack direction like this allows expressing the traditional stack directions along an axis, as well as intermediary for transition animations or diagonal directions.

Note that collapsed items (layout size zero) are skipped, so the previous and next items are both non-empty in layout.

Alignment & Spacing

The direction type can express non-fill alignment and spacing by it self, but prefer using the stack::children_align and stack::spacing properties as they are more readable and include fill alignment.

The Stack! widget implements alignment along the axis that does not change, so if the computed layout vector is zero in a dimension the items can fill in that dimension.

The Stack! widget adds the spacing along non-zero axis for each item offset after the first, so the spacing is not added for a perfect straight column or row, but it is added even for a single pixel shift diagonal stack.

Fields

place: Point

Point on the previous item where the next item is placed.

origin: Point

Point on the next item that is offset to match place.

is_rtl_aware: bool

If place.x and origin.x are swapped in LayoutDirection::RTL contexts.

Implementations

impl StackDirection

pub fn new<P, O>(place: P, origin: O, is_rtl_aware: bool) -> StackDirection

where P: Into<Point>, O: Into<Point>,

New custom direction.

pub fn left_to_right() -> StackDirection

((100.pct(), 0), (0, 0)), items are placed in a row from left to right.

Alignment works on the y direction because it is not affected.

pub fn right_to_left() -> StackDirection

((0, 0), (100.pct(), 0)), items are placed in a row from right to left.

Alignment works on the y direction because it is not affected.

pub fn start_to_end() -> StackDirection

((100.pct(), 0), (0, 0), true), items are placed in a row from left to right or from right to left in RTL contexts.

In LayoutDirection::RTL contexts the place.x and origin.x values are swapped before they are computed.

Alignment works on the y direction because it is not affected.

pub fn end_to_start() -> StackDirection

((0, 0), (100.pct(), 0)), true), items are placed in a row from right to left or from left to right in RTL contexts.

In LayoutDirection::RTL contexts the place.x and origin.x values are swapped before they are computed.

Alignment works on the y direction because it is not affected.

pub fn top_to_bottom() -> StackDirection

((0, 100.pct()), (0, 0)), items are placed in a column from top to bottom.

Alignment works on the x direction because it is not affected.

pub fn bottom_to_top() -> StackDirection

(0, 0), (0, 100.pct()), items are placed in a column from bottom to top.

Alignment works on the x direction because it is not affected.

pub fn none() -> StackDirection

(0, 0), items are just stacked in the Z order.

Fill alignment works in both dimensions because they don’t change.

Note that items are always rendered in the order defined by the z_index property.

pub fn layout( &self, prev_item: Rect<Px, Px>, next_item: Size2D<Px, Px>, ) -> Vector2D<Px, Px>

Compute offset of the next item in the current LAYOUT context.

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

Factor that defines the proportional direction.

Values are in the range of -1.0..=1.0.

pub fn direction_scale(&self) -> Factor2d

Scale proportional to how one dimensional the direction is.

Values are in the 0.0..=1.0 range where 0 is 20º or more from a single direction and 1 is 0º or 90º.

pub fn affect_mask(&self) -> LayoutMask

Compute a LayoutMask that flags all contextual values that affect the result of layout.

pub fn is_default(&self) -> bool

Returns true if all values are Length::Default.

Trait Implementations

impl Add for StackDirection

type Output = StackDirection

The resulting type after applying the + operator.

fn add(self, rhs: StackDirection) -> StackDirection

Performs the + operation.

impl AddAssign for StackDirection

fn add_assign(&mut self, rhs: StackDirection)

Performs the += operation.

impl Clone for StackDirection

fn clone(&self) -> StackDirection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StackDirection

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

Formats the value using the given formatter.

impl Default for StackDirection

fn default() -> StackDirection

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StackDirection

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StackDirection

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

Formats the value using the given formatter.

impl<'a, S> Div<S> for &'a StackDirection

where S: Into<Factor2d>,

type Output = StackDirection

The resulting type after applying the / operator.

fn div(self, rhs: S) -> <&'a StackDirection as Div<S>>::Output

Performs the / operation.

impl<S> Div<S> for StackDirection

where S: Into<Factor2d>,

type Output = StackDirection

The resulting type after applying the / operator.

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

Performs the / operation.

impl<S> DivAssign<S> for StackDirection

where S: Into<Factor2d>,

fn div_assign(&mut self, rhs: S)

Performs the /= operation.

impl<P, O> From<(P, O)> for StackDirection

where P: Into<Point>, O: Into<Point>,

fn from(_: (P, O)) -> StackDirection

New from place and origin, not RTL aware.

impl<P, O> From<(P, O, bool)> for StackDirection

where P: Into<Point>, O: Into<Point>,

fn from(_: (P, O, bool)) -> StackDirection

New from place, origin, and RTL aware flag.

impl<P, O> IntoVar<StackDirection> for (P, O)

where P: Into<Point>, O: Into<Point>,

fn into_var(self) -> <(P, O) as IntoVar<StackDirection>>::Var

New from place and origin, not RTL aware.

type Var = LocalVar<StackDirection>

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<P, O> IntoVar<StackDirection> for (P, O, bool)

where P: Into<Point>, O: Into<Point>,

fn into_var(self) -> <(P, O, bool) as IntoVar<StackDirection>>::Var

New from place, origin, and RTL aware flag.

type Var = LocalVar<StackDirection>

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<'a, S> Mul<S> for &'a StackDirection

where S: Into<Factor2d>,

type Output = StackDirection

The resulting type after applying the * operator.

fn mul(self, rhs: S) -> <&'a StackDirection as Mul<S>>::Output

Performs the * operation.

impl<S> Mul<S> for StackDirection

where S: Into<Factor2d>,

type Output = StackDirection

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S> MulAssign<S> for StackDirection

where S: Into<Factor2d>,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl PartialEq for StackDirection

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

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 Sub for StackDirection

type Output = StackDirection

The resulting type after applying the - operator.

fn sub(self, rhs: StackDirection) -> StackDirection

Performs the - operation.

impl SubAssign for StackDirection

fn sub_assign(&mut self, rhs: StackDirection)

Performs the -= operation.

impl Transitionable for StackDirection

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

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

impl<P, O> IntoValue<StackDirection> for (P, O)

where P: Into<Point>, O: Into<Point>,

impl<P, O> IntoValue<StackDirection> for (P, O, bool)

where P: Into<Point>, O: Into<Point>,

impl StructuralPartialEq for StackDirection