Struct hobo::components::AnimateTransform

pub struct AnimateTransform(pub Entity);

Tuple Fields

0: Entity

Trait Implementations

impl AsEntity for AnimateTransform

pub fn as_entity(&self) -> Entity

fn try_get_cmp<'a, C>(
    &self
) -> Option<OwningRef<OwningRef<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static, Global>>>, Ref<'a, Box<dyn DynStorage + 'static, Global>>>, SimpleStorage<C>>, C>> where
    C: 'static, 

fn try_get_cmp_mut<'a, C>(
    &self
) -> Option<OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static, Global>>>, RefMut<'a, Box<dyn DynStorage + 'static, Global>>>, SimpleStorage<C>>>, C>> where
    C: 'static, 

fn get_cmp<'a, C>(
    &self
) -> OwningRef<OwningRef<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static, Global>>>, Ref<'a, Box<dyn DynStorage + 'static, Global>>>, SimpleStorage<C>>, C> where
    C: 'static, 

fn get_cmp_mut<'a, C>(
    &self
) -> OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static, Global>>>, RefMut<'a, Box<dyn DynStorage + 'static, Global>>>, SimpleStorage<C>>>, C> where
    C: 'static, 

fn get_cmp_mut_or<'a, C>(
    &self,
    f: impl FnOnce() -> C
) -> OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static, Global>>>, RefMut<'a, Box<dyn DynStorage + 'static, Global>>>, SimpleStorage<C>>>, C> where
    C: 'static, 

fn get_cmp_mut_or_default<'a, C>(
    &self
) -> OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static, Global>>>, RefMut<'a, Box<dyn DynStorage + 'static, Global>>>, SimpleStorage<C>>>, C> where
    C: 'static + Default, 

fn remove_cmp<C>(&self) where
    C: 'static, 

fn find_in_ancestors<Q>(&self) -> Vec<<Q as Query>::Fetch, Global> where
    Q: Query, 

fn try_find_first_in_ancestors<Q>(&self) -> Option<<Q as Query>::Fetch> where
    Q: Query, 

fn find_first_in_ancestors<Q>(&self) -> <Q as Query>::Fetch where
    Q: Query, 

fn find_in_descendants<Q>(&self) -> Vec<<Q as Query>::Fetch, Global> where
    Q: Query, 

fn find_in_children<Q>(&self) -> Vec<<Q as Query>::Fetch, Global> where
    Q: Query, 

fn try_find_first_in_descendants<Q>(&self) -> Option<<Q as Query>::Fetch> where
    Q: Query, 

fn try_find_first_in_children<Q>(&self) -> Option<<Q as Query>::Fetch> where
    Q: Query, 

fn find_first_in_descendants<Q>(&self) -> <Q as Query>::Fetch where
    Q: Query, 

fn find_first_in_children<Q>(&self) -> <Q as Query>::Fetch where
    Q: Query, 

fn has_cmp<C>(&self) -> bool where
    C: 'static, 

fn remove(&self)

fn is_dead(&self) -> bool

fn add_component<T>(&self, component: T) where
    T: 'static, 

fn component<T>(self, component: T) -> Self where
    T: 'static, 

impl Clone for AnimateTransform

pub fn clone(&self) -> AnimateTransform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AnimateTransform

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

Formats the value using the given formatter.

impl Element for AnimateTransform

fn add_child(&self, child: impl Element)

fn child(self, child: impl Element) -> Self

fn add_children<Item>(&self, children: impl IntoIterator<Item = Item>) where
    Item: Element, 

fn children<Item>(self, children: impl IntoIterator<Item = Item>) -> Self where
    Item: Element, 

fn leave_parent(self)

fn add_child_at(&self, at_id: usize, child: impl Element)

fn add_child_signal<S, E>(&self, signal: S) where
    E: Element,
    S: 'static + Signal<Item = E>, 

fn child_signal<S, E>(self, signal: S) -> Self where
    E: Element,
    S: 'static + Signal<Item = E>, 

fn set_class_tagged<Tag>(&self, tag: Tag, style: impl Into<Style>) where
    Tag: 'static + Hash, 

fn set_class_typed<Type>(&self, style: Style) where
    Type: 'static, 

fn set_class(&self, style: impl Into<Style>)

fn add_class(&self, style: impl Into<Style>)

fn class(self, style: impl Into<Style>) -> Self

fn class_tagged<Tag>(self, tag: Tag, style: impl Into<Style>) -> Self where
    Tag: 'static + Hash, 

fn class_typed<Type>(self, style: Style) -> Self where
    Type: 'static, 

fn set_class_signal<S, I>(&self, signal: S) where
    I: Into<Style>,
    S: 'static + Signal<Item = I>, 

fn class_signal<S, I>(self, signal: S) -> Self where
    I: Into<Style>,
    S: 'static + Signal<Item = I>, 

fn set_class_typed_signal<Type, S, I>(&self, signal: S) where
    Type: 'static,
    I: Into<Style>,
    S: 'static + Signal<Item = I>, 

fn class_typed_signal<Type, S, I>(self, signal: S) -> Self where
    Type: 'static,
    I: Into<Style>,
    S: 'static + Signal<Item = I>, 

fn set_class_tagged_signal<Tag, S, I>(&self, tag: Tag, signal: S) where
    Tag: 'static + Hash + Copy,
    I: Into<Style>,
    S: 'static + Signal<Item = I>, 

fn class_tagged_signal<Tag, S, I>(self, tag: Tag, signal: S) -> Self where
    Tag: 'static + Hash + Copy,
    I: Into<Style>,
    S: 'static + Signal<Item = I>, 

fn set_attr<'k, 'v>(
    &self,
    key: impl Into<Cow<'k, str>>,
    value: impl Into<Cow<'v, str>>
)

fn attr<'k, 'v>(
    self,
    key: impl Into<Cow<'k, str>>,
    value: impl Into<Cow<'v, str>>
) -> Self

fn set_bool_attr<'k>(&self, key: impl Into<Cow<'k, str>>, value: bool)

fn bool_attr<'k>(self, key: impl Into<Cow<'k, str>>, value: bool) -> Self

fn remove_attr<'k>(&self, key: impl Into<Cow<'k, str>>)

fn set_attr_signal<'k, 'v, S, K, V>(&self, signal: S) where
    K: Into<Cow<'k, str>>,
    V: Into<Cow<'v, str>>,
    S: 'static + Signal<Item = (K, V)>, 

fn attr_signal<'k, 'v, S, K, V>(self, x: S) -> Self where
    K: Into<Cow<'k, str>>,
    V: Into<Cow<'v, str>>,
    S: 'static + Signal<Item = (K, V)>, 

fn set_bool_attr_signal<'k, S, K>(&self, attr: K, signal: S) where
    K: Into<Cow<'k, str>>,
    S: 'static + Signal<Item = bool>, 

fn bool_attr_signal<'k, S, K>(self, attr: K, x: S) -> Self where
    K: Into<Cow<'k, str>>,
    S: 'static + Signal<Item = bool>, 

fn set_text<'a>(&self, text: impl Into<Cow<'a, str>>)

fn text<'a>(self, x: impl Into<Cow<'a, str>>) -> Self

fn set_text_signal<'a, S, I>(&self, signal: S) where
    I: Into<Cow<'a, str>>,
    S: 'static + Signal<Item = I>, 

fn text_signal<'a, S, I>(self, x: S) -> Self where
    I: Into<Cow<'a, str>>,
    S: 'static + Signal<Item = I>, 

fn set_style(&self, style: impl AppendProperty)

fn style(self, style: impl AppendProperty) -> Self

fn remove_style(&self)

fn set_style_signal<S, I>(&self, signal: S) where
    I: AppendProperty,
    S: 'static + Signal<Item = I>, 

fn style_signal<S, I>(self, signal: S) -> Self where
    I: AppendProperty,
    S: 'static + Signal<Item = I>, 

fn mark<T>(self) -> Self where
    T: 'static, 

fn unmark<T>(self) -> Self where
    T: 'static, 

fn mark_signal<T, S>(self, signal: S) -> Self where
    T: 'static,
    S: 'static + Signal<Item = bool>, 

fn with_component<T>(self, f: impl FnOnce(&Self) -> T) -> Self where
    T: 'static, 

fn replace_with<T>(&self, other: T) -> T where
    T: Element, 

fn with(self, f: impl FnOnce(&Self)) -> Self

fn erase(&self) -> SomeElement

impl Hash for AnimateTransform

pub 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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<AnimateTransform> for AnimateTransform

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Copy for AnimateTransform

impl Eq for AnimateTransform

impl StructuralEq for AnimateTransform

impl StructuralPartialEq for AnimateTransform