Struct hobo::create::P

pub struct P(pub Entity);

Tuple Fields

0: Entity

Trait Implementations

impl AsElement for P

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 P

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 P

fn clone(&self) -> P

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for P

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

Formats the value using the given formatter.

impl Hash for P

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<P> for P

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

impl Eq for P

impl StructuralEq for P

impl StructuralPartialEq for P