Struct savory_html::prelude::El

pub struct El<Ms> {
    pub tag: Tag,
    pub attrs: Attrs,
    pub style: Style,
    pub event_handler_manager: EventHandlerManager<Ms>,
    pub children: Vec<Node<Ms>>,
    pub namespace: Option<Namespace>,
    pub node_ws: Option<Node>,
    pub refs: Vec<SharedNodeWs>,
    pub key: Option<ElKey>,
}

A component in our virtual DOM.

Note: Listeners in El's event_handler_manager are not cloned, but recreated during VDOM patching.

MDN reference web_sys reference

Fields

tag: Tag

attrs: Attrs

style: Style

event_handler_manager: EventHandlerManager<Ms>

children: Vec<Node<Ms>>

namespace: Option<Namespace>

node_ws: Option<Node>

The actual DOM element/node.

refs: Vec<SharedNodeWs>

key: Option<ElKey>

Implementations

impl<Ms> El<Ms>

pub fn empty(tag: Tag) -> El<Ms>

Create an empty element, specifying only the tag

pub fn empty_svg(tag: Tag) -> El<Ms>

Create an empty SVG element, specifying only the tag

pub fn from_markdown(markdown: &str) -> Vec<Node<Ms>>

Create elements from a markdown string. Note: All additional markdown extensions enabled.

pub fn from_html(html: &str) -> Vec<Node<Ms>>

Create elements from an HTML string.

pub fn add_child(&mut self, element: Node<Ms>) -> &mut El<Ms>

Add a new child to the element

pub fn add_attr(
    &mut self,
    key: impl Into<Cow<'static, str>>,
    val: impl Into<AtValue>
) -> &mut El<Ms>

Add an attribute (eg class, or href)

pub fn add_class(&mut self, name: impl Into<Cow<'static, str>>) -> &mut El<Ms>

Add a class. May be cleaner than add_attr

pub fn add_style(
    &mut self,
    key: impl Into<St>,
    val: impl Into<CSSValue>
) -> &mut El<Ms>

Add a new style (eg display, or height),

pub fn add_event_handler(
    &mut self,
    event_handler: EventHandler<Ms>
) -> &mut El<Ms>

Add a new event handler.

pub fn add_text(&mut self, text: impl Into<Cow<'static, str>>) -> &mut El<Ms>

Add a text node to the element. (ie between the HTML tags).

pub fn replace_text(
    &mut self,
    text: impl Into<Cow<'static, str>>
) -> &mut El<Ms>

Replace the element's text. Removes all text nodes from element, then adds the new one.

pub fn get_text(&self) -> String

pub fn warn_about_script_tags(&self)

Warn user about potential bugs when having scripts and Takeover mount type.

pub fn strip_ws_nodes_from_self_and_children(&mut self)

Remove websys nodes.

pub fn is_custom(&self) -> bool

Is it a custom element?

Trait Implementations

impl<Msg> AddForEl<&'static str> for El<Msg>

fn add(self, val: &'static str) -> Self

impl<Msg> AddForEl<Class> for El<Msg>

fn add(self, val: Class) -> Self

impl<Msg> AddForEl<Cow<'static, str>> for El<Msg>

fn add(self, val: Cow<'static, str>) -> Self

impl<Msg> AddForEl<Node<Msg>> for El<Msg>

fn add(self, val: Node<Msg>) -> Self

impl<Msg> AddForEl<String> for El<Msg>

fn add(self, val: String) -> Self

impl<Msg> AddForEl<Style> for El<Msg>

fn add(self, val: Style) -> Self

impl<Msg> AddForEl<Vec<Node<Msg>>> for El<Msg>

fn add(self, val: Vec<Node<Msg>>) -> Self

impl<Ms> Clone for El<Ms>

fn clone(&self) -> El<Ms>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Ms> Debug for El<Ms> where
    Ms: Debug, 

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

Formats the value using the given formatter.

impl<Msg> ElExt<Msg> for El<Msg>

fn try_add_style(self, val: Option<Style>) -> Self

fn set_style(self, val: Style) -> Self

fn try_set_style(self, val: Option<Style>) -> Self

fn and_style(self, conf: impl FnOnce(Style) -> Style) -> Self

fn set_attribute(self, val: Attribute) -> Self

fn try_set_attribute(self, val: Option<Attribute>) -> Self

fn set_attributes(self, val: Attributes) -> Self

fn and_attributes(self, conf: impl FnOnce(Attributes) -> Attributes) -> Self

fn add_children(self, children: impl IntoIterator<Item = Node<Msg>>) -> Self

fn try_add_children(
    self,
    children: Option<impl IntoIterator<Item = Node<Msg>>>
) -> Self

fn set_children(self, children: impl IntoIterator<Item = Node<Msg>>) -> Self

fn try_set_children(
    self,
    children: Option<impl IntoIterator<Item = Node<Msg>>>
) -> Self

fn get_class(&self) -> Option<Class>

fn class(self, class: impl Into<Class>) -> Self

fn get_id(&self) -> Option<Id>

fn try_id(self, id: Option<impl Into<Id>>) -> Self

fn id(self, id: impl Into<Id>) -> Self

fn el_ref<E: Clone>(self, reference: &ElRef<E>) -> Self

fn config(self, conf: impl FnOnce(Self) -> Self) -> Self

fn config_if(self, condition: bool, conf: impl FnOnce(Self) -> Self) -> Self

fn config_if_else(
    self,
    condition: bool,
    true_conf: impl FnOnce(Self) -> Self,
    false_conf: impl FnOnce(Self) -> Self
) -> Self

fn for_class(
    self,
    class: impl Into<Class>,
    f: impl Fn(Node<Msg>) -> Node<Msg> + Copy
) -> Self

fn for_id(
    self,
    id: impl Into<Id>,
    f: impl Fn(Node<Msg>) -> Node<Msg> + Copy
) -> Self

impl<Msg: 'static> EventsApi<Msg> for El<Msg>

fn on_scroll<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_after_print<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_before_print<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_app_installed<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_seeked<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_seeking<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_play<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_playing<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_rate_change<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_can_play<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_can_play_through<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_reset<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_change<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_load<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_unload<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_abort<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_error<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_emptied<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_ended<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_full_screen_change<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_full_screen_error<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_invalid<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_offline<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_online<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_select_start<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_selectionchange<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_submit<EMsg: 'static>(
    self,
    handler: impl FnOnce(Event) -> EMsg + 'static + Clone
) -> Self

fn on_blur<EMsg: 'static>(
    self,
    handler: impl FnOnce(FocusEvent) -> EMsg + 'static + Clone
) -> Self

fn on_focus<EMsg: 'static>(
    self,
    handler: impl FnOnce(FocusEvent) -> EMsg + 'static + Clone
) -> Self

fn on_focus_in<EMsg: 'static>(
    self,
    handler: impl FnOnce(FocusEvent) -> EMsg + 'static + Clone
) -> Self

fn on_focus_out<EMsg: 'static>(
    self,
    handler: impl FnOnce(FocusEvent) -> EMsg + 'static + Clone
) -> Self

fn on_aux_click<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_click<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_double_click<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_down<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_enter<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_leave<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_move<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_out<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_over<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_mouse_up<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_context_menu<EMsg: 'static>(
    self,
    handler: impl FnOnce(MouseEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_cancel<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_down<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_enter<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_leave<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_move<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_out<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_over<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_pointer_up<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_lost_pointer_capture<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_got_pointer_capture<EMsg: 'static>(
    self,
    handler: impl FnOnce(PointerEvent) -> EMsg + 'static + Clone
) -> Self

fn on_wheel<EMsg: 'static>(
    self,
    handler: impl FnOnce(WheelEvent) -> EMsg + 'static + Clone
) -> Self

fn on_before_input<EMsg: 'static>(
    self,
    handler: impl FnOnce(InputEvent) -> EMsg + 'static + Clone
) -> Self

fn on_input<EMsg: 'static>(
    self,
    handler: impl FnOnce(InputEvent) -> EMsg + 'static + Clone
) -> Self

fn on_key_down<EMsg: 'static>(
    self,
    handler: impl FnOnce(KeyboardEvent) -> EMsg + 'static + Clone
) -> Self

fn on_key_up<EMsg: 'static>(
    self,
    handler: impl FnOnce(KeyboardEvent) -> EMsg + 'static + Clone
) -> Self

fn on_composition_start<EMsg: 'static>(
    self,
    handler: impl FnOnce(CompositionEvent) -> EMsg + 'static + Clone
) -> Self

fn on_composition_update<EMsg: 'static>(
    self,
    handler: impl FnOnce(CompositionEvent) -> EMsg + 'static + Clone
) -> Self

fn on_composition_end<EMsg: 'static>(
    self,
    handler: impl FnOnce(CompositionEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drag<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drag_end<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drag_enter<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drag_leave<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drag_over<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drag_start<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_drop<EMsg: 'static>(
    self,
    handler: impl FnOnce(DragEvent) -> EMsg + 'static + Clone
) -> Self

fn on_resize<EMsg: 'static>(
    self,
    handler: impl FnOnce(UiEvent) -> EMsg + 'static + Clone
) -> Self

fn on_select<EMsg: 'static>(
    self,
    handler: impl FnOnce(UiEvent) -> EMsg + 'static + Clone
) -> Self

impl<'_, Ms> From<&'_ Element> for El<Ms>

fn from(ws_el: &Element) -> El<Ms>

Create a vdom node from a web_sys::Element. Used in creating elements from html and markdown strings. Includes children, recursively added.

impl<Ms, OtherMs> MessageMapper<Ms, OtherMs> for El<Ms> where
    Ms: 'static,
    OtherMs: 'static, 

type SelfWithOtherMs = El<OtherMs>

fn map_msg(self, f: impl Clone + FnOnce(Ms) -> OtherMs + 'static) -> El<OtherMs>

Maps an element's message to have another message.

This allows third party components to integrate with your application without having to know about your Msg type beforehand.

Note

There is an overhead to calling this versus keeping all messages under one type. The deeper the nested structure of children, the more time this will take to run.

impl<Msg> SetForEl<&'static str> for El<Msg>

fn set(self, val: &'static str) -> Self

impl<Msg> SetForEl<Attributes> for El<Msg>

fn set(self, val: Attributes) -> Self

impl<Msg> SetForEl<Cow<'static, str>> for El<Msg>

fn set(self, val: Cow<'static, str>) -> Self

impl<Msg> SetForEl<Node<Msg>> for El<Msg>

fn set(self, val: Node<Msg>) -> Self

impl<Msg> SetForEl<String> for El<Msg>

fn set(self, val: String) -> Self

impl<Msg> SetForEl<Style> for El<Msg>

fn set(self, val: Style) -> Self

impl<T: Into<Attribute>, Msg> SetForEl<T> for El<Msg>

fn set(self, val: T) -> Self

impl<Msg> SetForEl<Vec<Node<Msg>>> for El<Msg>

fn set(self, val: Vec<Node<Msg>>) -> Self

impl<Msg> TryAddForEl<Option<&'static str>> for El<Msg>

fn try_add(self, val: Option<&'static str>) -> Self

impl<Msg> TryAddForEl<Option<Class>> for El<Msg>

fn try_add(self, val: Option<Class>) -> Self

impl<Msg> TryAddForEl<Option<Cow<'static, str>>> for El<Msg>

fn try_add(self, val: Option<Cow<'static, str>>) -> Self

impl<Msg> TryAddForEl<Option<Node<Msg>>> for El<Msg>

fn try_add(self, val: Option<Node<Msg>>) -> Self

impl<Msg> TryAddForEl<Option<String>> for El<Msg>

fn try_add(self, val: Option<String>) -> Self

impl<Msg> TryAddForEl<Option<Style>> for El<Msg>

fn try_add(self, val: Option<Style>) -> Self

impl<Msg> TryAddForEl<Option<Vec<Node<Msg>>>> for El<Msg>

fn try_add(self, val: Option<Vec<Node<Msg>>>) -> Self

impl<Msg> TrySetForEl<Option<&'static str>> for El<Msg>

fn try_set(self, val: Option<&'static str>) -> Self

impl<Msg> TrySetForEl<Option<Cow<'static, str>>> for El<Msg>

fn try_set(self, val: Option<Cow<'static, str>>) -> Self

impl<Msg> TrySetForEl<Option<Node<Msg>>> for El<Msg>

fn try_set(self, val: Option<Node<Msg>>) -> Self

impl<Msg> TrySetForEl<Option<String>> for El<Msg>

fn try_set(self, val: Option<String>) -> Self

impl<Msg> TrySetForEl<Option<Style>> for El<Msg>

fn try_set(self, val: Option<Style>) -> Self

impl<T: Into<Attribute>, Msg> TrySetForEl<Option<T>> for El<Msg>

fn try_set(self, val: Option<T>) -> Self

impl<Msg> TrySetForEl<Option<Vec<Node<Msg>>>> for El<Msg>

fn try_set(self, val: Option<Vec<Node<Msg>>>) -> Self

impl<Ms> UpdateEl<Ms> for El<Ms>

fn update_el(self, el: &mut El<Ms>)