Struct 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where 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) -> Self

where Self: Sized,

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

where 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, ) -> Self

where Self: Sized,

impl Clone for Line

fn clone(&self) -> Line

Returns a duplicate 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 for Line

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

Tests for self and other values to be equal, and is used by ==.

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

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