Skip to main content

Alignment

waterui_layout::stack

Struct Alignment

pub struct Alignment { /* private fields */ }

Expand description

Combined two-dimensional alignment used by layout containers.

Implementations§

impl Alignment

pub const Top: Alignment

Top-center alignment.

pub const TopLeading: Alignment

Top-leading alignment.

pub const TopTrailing: Alignment

Top-trailing alignment.

pub const Center: Alignment

Center alignment.

pub const Leading: Alignment

Leading-center alignment.

pub const Trailing: Alignment

Trailing-center alignment.

pub const Bottom: Alignment

Bottom-center alignment.

pub const BottomLeading: Alignment

Bottom-leading alignment.

pub const BottomTrailing: Alignment

Bottom-trailing alignment.

pub const fn new( horizontal: HorizontalAlignment, vertical: VerticalAlignment, ) -> Alignment

Creates a combined alignment from horizontal and vertical guides.

pub const fn horizontal(&self) -> HorizontalAlignment

Returns the horizontal component.

pub const fn vertical(&self) -> VerticalAlignment

Returns the vertical component.

Trait Implementations§

impl Clone for Alignment

fn clone(&self) -> Alignment

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more

impl Copy for Alignment

impl Debug for Alignment

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

Formats the value using the given formatter. Read more

impl Default for Alignment

fn default() -> Alignment

Returns the “default value” for a type. Read more

impl Eq for Alignment

impl From<Alignment> for UnitPoint

fn from(alignment: Alignment) -> UnitPoint

Converts to this type from the input type.

impl From<Bottom> for Alignment

fn from(_: Bottom) -> Self

Converts to this type from the input type.

impl From<BottomLeading> for Alignment

fn from(_: BottomLeading) -> Self

Converts to this type from the input type.

impl From<BottomTrailing> for Alignment

fn from(_: BottomTrailing) -> Self

Converts to this type from the input type.

impl From<Center> for Alignment

fn from(_: Center) -> Self

Converts to this type from the input type.

impl From<Leading> for Alignment

fn from(_: Leading) -> Self

Converts to this type from the input type.

impl From<Top> for Alignment

fn from(_: Top) -> Self

Converts to this type from the input type.

impl From<TopLeading> for Alignment

fn from(_: TopLeading) -> Self

Converts to this type from the input type.

impl From<TopTrailing> for Alignment

fn from(_: TopTrailing) -> Self

Converts to this type from the input type.

impl From<Trailing> for Alignment

fn from(_: Trailing) -> Self

Converts to this type from the input type.

impl PartialEq for Alignment

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

Equality operator ==. Read more

1.0.0 (const: unstable) · Source§

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

Inequality operator !=. Read more

impl Signal for Alignment

type Output = Alignment

The type of value produced by this computation.

type Guard = ()

The guard type returned by the watch method that manages watcher lifecycle.

fn get(&self) -> <Alignment as Signal>::Output

Execute the computation and return the current value.

fn watch( &self, _watcher: impl Fn(Context<<Alignment as Signal>::Output>) + 'static, )

Register a watcher to be notified when the computed value changes. Read more

fn identity(&self) -> Option<SignalIdentity>

Returns the stable semantic identity of this signal, when one exists. Read more

impl StructuralPartialEq for Alignment

Auto Trait Implementations§

impl Freeze for Alignment

impl RefUnwindSafe for Alignment

impl Send for Alignment

impl Sync for Alignment

impl Unpin for Alignment

impl UnsafeUnpin for Alignment

impl UnwindSafe for Alignment

Blanket Implementations§

impl<S> AnimationExt for S
where S: SignalExt,

fn animated(&self) -> WithMetadata<Self, Animation>

Attach the system-default animation to this reactive value. Read more

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IdentifiableExt for T

fn use_id<F, Id>(self, f: F) -> UseId<Self, F>
where F: Fn(&Self) -> Id, Id: Ord + Hash,

Wraps the value in a UseId with the provided identification function.

fn self_id(self) -> SelfId<Self>

Wraps the value in a SelfId, making the value serve as its own identifier.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<C, Output> IntoComputed<Output> for C
where C: IntoSignal<Output> + 'static, <C as IntoSignal<Output>>::Signal: Clone + 'static,

fn into_computed(self) -> Computed<Output>

Convert this value into a Computed<Output>.

impl<C, Output> IntoSignal<Output> for C
where C: Signal, <C as Signal>::Output: 'static + Clone, Output: From<<C as Signal>::Output> + 'static,

fn into_signal(self) -> <C as IntoSignal<Output>>::Signal

Convert this computation into one that produces the desired output type.

type Signal = Map<C, fn(<C as Signal>::Output) -> Output, Output>

The specific computation type that will be produced.

impl<C> SignalExt for C
where C: Signal,

fn map<F, Output>(&self, f: F) -> Map<Self, F, Output>
where F: 'static + Clone + Fn(Self::Output) -> Output, Output: 'static, Self: 'static,

Transforms the output of this signal using the provided function.

fn zip<B>(&self, b: &B) -> Zip<Self, B>
where B: Signal, Self::Output: Clone, <B as Signal>::Output: Clone,

Combines this signal with another signal into a tuple.

fn cached(&self) -> Cached<Self>
where Self::Output: Clone,

Wraps this signal with caching to avoid redundant computations.

fn computed(&self) -> Computed<Self::Output>
where Self: 'static,

Converts this signal into a type-erased Computed container.

fn with<T>(&self, metadata: T) -> WithMetadata<Self, T>
where T: 'static,

Attaches metadata to this signal’s watcher notifications.

fn map_into<U>(&self) -> Map<Self, fn(Self::Output) -> U, U>
where Self: 'static, Self::Output: Into<U>, U: 'static,

Transforms the output using Into::into.

fn inspect<F>( &self, f: F, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, Self::Output>
where Self: 'static, Self::Output: Clone + 'static, F: 'static + Clone + Fn(&Self::Output),

Applies a side-effect function and returns the original value.

fn distinct(&self) -> Distinct<Self>
where Self::Output: PartialEq + Clone,

Creates a distinct signal that only notifies on value changes.

fn equal_to( &self, other: Self::Output, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, bool>
where Self: 'static, Self::Output: Clone + PartialEq + 'static,

Returns true if the value equals the given value. Read more

fn condition<F>( &self, predicate: F, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, bool>
where Self: 'static, F: 'static + Clone + Fn(&Self::Output) -> bool,

Returns true if the predicate returns true for the value.

fn gt( &self, other: Self::Output, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, bool>
where Self: 'static, Self::Output: Clone + PartialOrd + 'static,

Returns true if the value is greater than the given value.

fn lt( &self, other: Self::Output, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, bool>
where Self: 'static, Self::Output: Clone + PartialOrd + 'static,

Returns true if the value is less than the given value.

fn ge( &self, other: Self::Output, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, bool>
where Self: 'static, Self::Output: Clone + PartialOrd + 'static,

Returns true if the value is greater than or equal to the given value.

fn le( &self, other: Self::Output, ) -> Map<Self, impl Clone + Fn(Self::Output) + 'static, bool>
where Self: 'static, Self::Output: Clone + PartialOrd + 'static,

Returns true if the value is less than or equal to the given value.

fn is_some<T>(&self) -> Map<Self, fn(Option<T>) -> bool, bool>
where Self: Signal<Output = Option<T>> + 'static, T: 'static,

Returns true if the Option is Some.

fn is_none<T>(&self) -> Map<Self, fn(Option<T>) -> bool, bool>
where Self: Signal<Output = Option<T>> + 'static, T: 'static,

Returns true if the Option is None.

fn unwrap_or<T>( &self, default: T, ) -> Map<Self, impl Clone + Fn(Option<T>) + 'static, T>
where Self: Signal<Output = Option<T>> + 'static, T: Clone + 'static,

Returns the contained value or a default.

fn unwrap_or_else<T, F>( &self, default: F, ) -> Map<Self, impl Clone + Fn(Option<T>) + 'static, T>
where Self: Signal<Output = Option<T>> + 'static, T: 'static, F: 'static + Clone + Fn() -> T,

Returns the contained value or computes it from a closure.

fn unwrap_or_default<T>(&self) -> Map<Self, fn(Option<T>) -> T, T>
where Self: Signal<Output = Option<T>> + 'static, T: Default + 'static,

Returns the contained value or the default value for that type.

fn some_equal_to<T>( &self, value: T, ) -> Map<Self, impl Clone + Fn(Option<T>) + 'static, bool>
where Self: Signal<Output = Option<T>> + 'static, T: Clone + PartialEq + 'static,

Returns true if the Option is Some and the value equals the given value.

fn flatten<T>(&self) -> Map<Self, fn(Option<Option<T>>) -> Option<T>, Option<T>>
where Self: Signal<Output = Option<Option<T>>> + 'static, T: 'static,

Flattens a nested Option<Option<T>> into Option<T>.

fn map_some<T, U, F>( &self, f: F, ) -> Map<Self, impl Clone + Fn(Option<T>) + 'static, Option<U>>
where Self: Signal<Output = Option<T>> + 'static, T: 'static, U: 'static, F: 'static + Clone + Fn(T) -> U,

Maps an Option<T> to Option<U> using the provided function.

fn and_then_some<T, U, F>( &self, f: F, ) -> Map<Self, impl Clone + Fn(Option<T>) + 'static, Option<U>>
where Self: Signal<Output = Option<T>> + 'static, T: 'static, U: 'static, F: 'static + Clone + Fn(T) -> Option<U>,

Returns None if the option is None, otherwise calls f with the wrapped value and returns the result.

fn not(&self) -> Map<Self, fn(bool) -> bool, bool>
where Self: Signal<Output = bool> + 'static,

Returns the logical negation of the boolean value.

fn and<B>(&self, other: &B) -> Map<Zip<Self, B>, fn((bool, bool)) -> bool, bool>
where Self: Signal<Output = bool> + 'static, B: Signal<Output = bool> + 'static,

Returns the logical AND of this signal with another boolean signal.

fn or<B>(&self, other: &B) -> Map<Zip<Self, B>, fn((bool, bool)) -> bool, bool>
where Self: Signal<Output = bool> + 'static, B: Signal<Output = bool> + 'static,

Returns the logical OR of this signal with another boolean signal.

fn then_some<T>( &self, value: T, ) -> Map<Self, impl Clone + Fn(bool) + 'static, Option<T>>
where Self: Signal<Output = bool> + 'static, T: Clone + 'static,

Returns Some(value) if true, otherwise None.

fn select<T>( &self, if_true: T, if_false: T, ) -> Map<Self, impl Clone + Fn(bool) + 'static, T>
where Self: Signal<Output = bool> + 'static, T: Clone + 'static,

Returns if_true if true, otherwise if_false.

fn negate<T>(&self) -> Map<Self, fn(T) -> T, T>
where Self: Signal<Output = T> + 'static, T: Signed + 'static,

Returns the negation of the value.

fn abs<T>(&self) -> Map<Self, fn(T) -> T, T>
where Self: Signal<Output = T> + 'static, T: Signed + 'static,

Returns the absolute value.

fn sign<T>(&self) -> Map<Self, fn(T) -> bool, bool>
where Self: Signal<Output = T> + 'static, T: Signed + 'static,

Returns true if the value is not negative (i.e., positive or zero).

fn is_positive<T>(&self) -> Map<Self, fn(T) -> bool, bool>
where Self: Signal<Output = T> + 'static, T: Signed + 'static,

Returns true if the value is positive.

fn is_negative<T>(&self) -> Map<Self, fn(T) -> bool, bool>
where Self: Signal<Output = T> + 'static, T: Signed + 'static,

Returns true if the value is negative.

fn is_zero<T>(&self) -> Map<Self, fn(T) -> bool, bool>
where Self: Signal<Output = T> + 'static, T: Zero + 'static,

Returns true if the value is zero.

fn is_ok<T, E>(&self) -> Map<Self, fn(Result<T, E>) -> bool, bool>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static,

Returns true if the Result is Ok.

fn is_err<T, E>(&self) -> Map<Self, fn(Result<T, E>) -> bool, bool>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static,

Returns true if the Result is Err.

fn ok<T, E>(&self) -> Map<Self, fn(Result<T, E>) -> Option<T>, Option<T>>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static,

Converts from Result<T, E> to Option<T>.

fn err<T, E>(&self) -> Map<Self, fn(Result<T, E>) -> Option<E>, Option<E>>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static,

Converts from Result<T, E> to Option<E>.

fn unwrap_or_result<T, E>( &self, default: T, ) -> Map<Self, impl Clone + Fn(Result<T, E>) + 'static, T>
where Self: Signal<Output = Result<T, E>> + 'static, T: Clone + 'static, E: 'static,

Returns the contained Ok value or a default.

fn unwrap_or_else_result<T, E, F>( &self, f: F, ) -> Map<Self, impl Clone + Fn(Result<T, E>) + 'static, T>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static, F: 'static + Clone + Fn(E) -> T,

Returns the contained Ok value or computes it from the error.

fn map_ok<T, E, U, F>( &self, f: F, ) -> Map<Self, impl Clone + Fn(Result<T, E>) + 'static, Result<U, E>>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static, U: 'static, F: 'static + Clone + Fn(T) -> U,

Maps a Result<T, E> to Result<U, E> using the provided function.

fn map_err<T, E, F, U>( &self, f: F, ) -> Map<Self, impl Clone + Fn(Result<T, E>) + 'static, Result<T, U>>
where Self: Signal<Output = Result<T, E>> + 'static, T: 'static, E: 'static, U: 'static, F: 'static + Clone + Fn(E) -> U,

Maps a Result<T, E> to Result<T, F> using the provided function.

fn debounce(&self, duration: Duration) -> Debounce<Self, DefaultExecutor>
where Self::Output: Clone,

Creates a debounced version of this signal. Read more

fn throttle(&self, duration: Duration) -> Throttle<Self, DefaultExecutor>
where Self::Output: Clone,

Creates a throttled version of this signal. Read more

fn str_is_empty<T>(&self) -> Map<Self, fn(T) -> bool, bool>
where Self: Signal<Output = T> + 'static, T: AsRef<str> + 'static,

Returns true if the string is empty. Read more

fn str_len<T>(&self) -> Map<Self, fn(T) -> usize, usize>
where Self: Signal<Output = T> + 'static, T: AsRef<str> + 'static,

Returns the length of the string in bytes.

fn str_contains<T>( &self, pattern: impl Into<String>, ) -> Map<Self, impl Clone + Fn(T) + 'static, bool>
where Self: Signal<Output = T> + 'static, T: AsRef<str> + 'static,

Returns true if the string contains the given pattern. Read more

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = !

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.