Struct hobo::create::Line

pub struct Line(pub Entity);

Tuple Fields

0: Entity

Implementations

impl Line

pub fn x1(self, x1: impl Num + ToString) -> Self

pub fn set_x1(&self, x1: impl Num + ToString)

pub fn x2(self, x2: impl Num + ToString) -> Self

pub fn set_x2(&self, x2: impl Num + ToString)

pub fn y1(self, y1: impl Num + ToString) -> Self

pub fn set_y1(&self, y1: impl Num + ToString)

pub fn y2(self, y2: impl Num + ToString) -> Self

pub fn set_y2(&self, y2: impl Num + ToString)

pub fn path_length(self, path_length: impl Num + ToString) -> Self

pub fn set_path_length(&self, path_length: impl Num + ToString)

Trait Implementations

impl AsElement for Line

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 Line

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 Line

fn clone(&self) -> Line

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Line

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

Formats the value using the given formatter.

impl Hash for Line

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

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

impl Eq for Line

impl StructuralEq for Line

impl StructuralPartialEq for Line