Struct hobo::create::Base

pub struct Base(pub Entity);

Tuple Fields

0: Entity

Trait Implementations

impl AsElement for Base

fn add_child<T: AsElement>(&self, child: T)

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

fn with_child<T: AsElement>(self, f: impl FnOnce(&Self) -> T) -> Self

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

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

fn leave_parent(self)

fn add_child_at<T: AsElement>(&self, at_index: usize, child: T)

add a child at an index, useful to update tables without regenerating the whole container element

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

fn child_signal<S, E>(self, signal: S) -> Selfwhere E: AsElement, S: Signal<Item = E> + 'static,

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

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

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: Hash + 'static>( self, tag: Tag, style: impl Into<Style> ) -> Self

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

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

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

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

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

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

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

fn get_attr<'k>(&self, key: impl Into<Cow<'k, str>>) -> Option<String>

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, attr: K, signal: S)where K: Into<Cow<'k, str>>, V: Into<Cow<'v, str>>, S: Signal<Item = V> + 'static,

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

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

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

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: Signal<Item = I> + 'static,

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

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: Signal<Item = I> + 'static,

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

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

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

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

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

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

fn parent(&self) -> Element

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

👎Deprecated: use .tap() instead

fn as_element(&self) -> Element

impl AsEntity for Base

fn as_entity(&self) -> Entity

fn try_get_cmp<'a, C: 'static>( &self ) -> Option<OwningRef<StorageGuard<C, StorageRef<'a, C>>, C>>where Self: Sized,

fn try_get_cmp_mut<'a, C: 'static>( &self ) -> Option<OwningRefMut<StorageGuardMut<C, StorageRefMut<'a, C>>, C>>where Self: Sized,

fn get_cmp<'a, C: 'static>( &self ) -> OwningRef<StorageGuard<C, StorageRef<'a, C>>, C>

fn get_cmp_mut<'a, C: 'static>( &self ) -> OwningRefMut<StorageGuardMut<C, StorageRefMut<'a, C>>, C>

fn get_cmp_mut_or<'a, C: 'static>( &self, f: impl FnOnce() -> C ) -> OwningRefMut<StorageGuardMut<C, StorageRefMut<'a, C>>, C>

fn get_cmp_mut_or_default<'a, C: 'static + Default>( &self ) -> OwningRefMut<StorageGuardMut<C, StorageRefMut<'a, C>>, C>

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

fn find_in_ancestors<Q: Query>(&self) -> Vec<Q::Fetch>

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

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

fn find_in_descendants<Q: Query>(&self) -> Vec<Q::Fetch>

fn find_in_children<Q: Query>(&self) -> Vec<Q::Fetch>

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

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

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

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

fn remove(&self)

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

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

fn has_cmp<C: 'static>(&self) -> boolwhere Self: Sized,

fn is_dead(&self) -> bool

fn spawn(&self, f: impl Future<Output = ()> + 'static)

fn spawn_in<F: FnOnce(&Self) -> Fut, Fut: Future<Output = ()> + 'static>( self, f: F ) -> Selfwhere Self: Sized,

impl Clone for Base

fn clone(&self) -> Base

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Base

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

Formats the value using the given formatter.

impl Hash for Base

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 PartialEq<Base> for Base

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Base

impl Eq for Base

impl StructuralEq for Base

impl StructuralPartialEq for Base