Struct respo::RespoElement

pub struct RespoElement<T>
where
    T: Debug + Clone,
{
    pub name: Rc<str>,
    pub attrs: HashMap<Rc<str>, String>,
    pub style: RespoStyle,
    pub children: Vec<(RespoIndexKey, RespoNode<T>)>,
    /* private fields */
}

internal abstraction for an element

Fields

name: Rc<str>

tagName

attrs: HashMap<Rc<str>, String>

style: RespoStyle

inlines styles, partially typed. there’s also a macro called static_styles for inserting CSS rules

children: Vec<(RespoIndexKey, RespoNode<T>)>

each child as a key like a string, by default generated from index, they are used in diffing, so it’s better to be distinct, although not required to be.

Implementations

impl<T> RespoElement<T>

where T: Debug + Clone,

pub fn named(name: &str) -> Self

pub fn to_node(self) -> RespoNode<T>

pub fn style(self, more: RespoStyle) -> Self

attach styles

element.style(RespoStyle::default().margin(10))

pub fn modify_style<U>(self, builder: U) -> Self

where U: Fn(&mut RespoStyle),

imparative way of updating style

element.modify_style(|s| {
  if data > 1 {
    s.color(CssColor::Red);
  }
});

pub fn attribute<U, V>(self, property: U, value: V) -> Self

where U: Into<Rc<str>> + ToOwned, V: Display,

set an attribute on element

pub fn maybe_attribute<U, V>(self, property: U, value: Option<V>) -> Self

where U: Into<Rc<str>> + ToOwned, V: Display,

set an attribute on element, but using None indicates noting

pub fn on_click<U>(self, handler: U) -> Self

where U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

pub fn on_input<U>(self, handler: U) -> Self

where U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

pub fn on_keydown<U>(self, handler: U) -> Self

where U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

handle keydown event

pub fn on_focus<U>(self, handler: U) -> Self

where U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

handle focus event

pub fn on_change<U>(self, handler: U) -> Self

where U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

handle change event

pub fn on_named_event<U>(self, name: &str, handler: U) -> Self

where U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

attach a listener by event name(only a small set of events are supported)

pub fn children<U>(self, more: U) -> Self

where U: IntoIterator<Item = RespoNode<T>>,

add children elements, index key are generated from index number

pub fn children_indexed<U>(self, more: U) -> Self

where U: IntoIterator<Item = (RespoIndexKey, RespoNode<T>)>,

add children elements, with index keys specified

pub fn elements<U>(self, mode: U) -> Self

where U: IntoIterator<Item = RespoElement<T>>,

add elements. if any component is involved, use self.children([]) instead

pub fn class<U>(self, name: U) -> Self

where U: Into<String>,

attach a class name for adding styles

pub fn maybe_class<U>(self, name: Option<U>) -> Self

where U: Into<String>,

attach an optional class name for adding styles

pub fn toggle_class<U>(self, name: U, on: bool) -> Self

where U: Into<String>,

attach a class name, controlled by a boolean

pub fn class_list<U>(self, names: &[U]) -> Self

where U: Into<String> + Clone,

attach a list of class names for adding styles

pub fn inner_text<U>(self, content: U) -> Self

where U: Into<String>,

writes innerText

pub fn inner_html<U>(self, content: U) -> Self

where U: Into<String>,

writes innerHTML

pub fn value<U>(self, content: U) -> Self

where U: Into<String>,

writes value

Trait Implementations

impl<T> Clone for RespoElement<T>

where T: Debug + Clone + Clone,

fn clone(&self) -> RespoElement<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RespoElement<T>

where T: Debug + Clone + Debug,

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

Formats the value using the given formatter.

impl From<RespoElement<()>> for RespoNode<()>

fn from(el: RespoElement<()>) -> Self

Converts to this type from the input type.

impl<T> PartialEq for RespoElement<T>

where T: Debug + Clone + PartialEq,

fn eq(&self, other: &RespoElement<T>) -> 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<T> Eq for RespoElement<T>

where T: Debug + Clone + Eq,

impl<T> StructuralPartialEq for RespoElement<T>

where T: Debug + Clone,