Struct sauron::Element

pub struct Element<MSG> {
    pub namespace: Option<&'static str>,
    pub tag: &'static str,
    pub self_closing: bool,
    /* private fields */
}

Represents an element of the virtual node An element has a generic tag, this tag could be a static str tag, such as usage in html dom. Example of which are div, a, input, img, etc.

Tag is a generic type, which can represent a different DOM tree other than the html dom such as widgets in native platform such as gtk, example of which are Hpane, Vbox, Image,

An element can have an optional namespace, such in the case for html dom where namespace like HTML and SVG, which needs to specified in order to create the DOM element to work on the browser.

The namespace is also needed in attributes where namespace are necessary such as xlink:href where the namespace xlink is needed in order for the linked element in an svg image to work.

Fields

namespace: Option<&'static str>

namespace of this element, svg elements requires namespace to render correcly in the browser

tag: &'static str

the element tag, such as div, a, button

self_closing: bool

is the element has a self closing tag

Implementations

impl<MSG> Element<MSG>

pub fn new( namespace: Option<&'static str>, tag: &'static str, attrs: impl IntoIterator<Item = Attribute<MSG>>, children: impl IntoIterator<Item = Node<MSG>>, self_closing: bool ) -> Element<MSG>

create a new instance of an element

pub fn add_attributes( &mut self, attrs: impl IntoIterator<Item = Attribute<MSG>> )

add attributes to this element

pub fn add_children(&mut self, children: impl IntoIterator<Item = Node<MSG>>)

add children virtual node to this element

pub fn children(&self) -> &[Node<MSG>]

returns a refernce to the children of this node

pub fn children_mut(&mut self) -> &mut [Node<MSG>]

returns a mutable reference to the children of this node

pub fn swap_remove_child(&mut self, index: usize) -> Node<MSG>

Removes an child node from this element and returns it.

The removed child is replaced by the last child of the element’s children.

Panics

Panics if index is out of bounds in children

pub fn swap_children(&mut self, a: usize, b: usize)

Swaps the 2 child node in this element

Arguments

• a - The index of the first child node
• b - The index of the second child node

Panics

Panics if both a and b are out of bounds

pub fn take_children(self) -> Vec<Node<MSG>>

consume self and return the children

pub fn attributes(&self) -> &[Attribute<MSG>]

return a reference to the attribute of this element

pub fn take_attributes(self) -> Vec<Attribute<MSG>>

consume self and return the attributes

pub fn namespace(&self) -> Option<&&'static str>

return the namespace of this element

pub fn tag(&self) -> &&'static str

return the tag of this element

pub fn take_tag(self) -> &'static str

consume self and return the tag of this element

pub fn set_tag(&mut self, tag: &'static str)

change the tag of this element

pub fn remove_attribute(&mut self, name: &&'static str)

remove the attributes with this key

pub fn set_attributes( &mut self, attrs: impl IntoIterator<Item = Attribute<MSG>> )

remove the existing values of this attribute and add the new values

pub fn merge_attributes( &mut self, new_attrs: impl IntoIterator<Item = Attribute<MSG>> )

merge to existing attributes if it exist

pub fn attribute_value( &self, name: &&'static str ) -> Option<Vec<&AttributeValue<MSG>>>

return all the attribute values which the name &AttributeName

pub fn first_value(&self, att_name: &&'static str) -> Option<&Value>

get the first value of the attribute which has the name att_name of this element

pub fn group_indexed_attributes_per_name<'a>( attrs: &'a [Attribute<MSG>] ) -> IndexMap<&'a &'static str, Vec<(usize, &'a Attribute<MSG>)>>

grouped the attributes, but retain the index of the attribute relative to its location in the element

pub fn has_mount_callback(&self) -> bool

return true if this element has a mount callback

impl<MSG> Element<MSG>

pub fn map_msg<F, MSG2>(self, cb: F) -> Element<MSG2>

where F: Fn(MSG) -> MSG2 + Clone + 'static, MSG2: 'static, MSG: 'static,

map the msg of this element such that Element<MSG> becomes Element<MSG2>

impl<MSG> Element<MSG>

pub fn render_with_indent( &self, buffer: &mut dyn Write, indent: usize, compressed: bool ) -> Result<(), Error>

render element nodes

Trait Implementations

impl<MSG> Clone for Element<MSG>

fn clone(&self) -> Element<MSG>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<MSG> Debug for Element<MSG>

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

Formats the value using the given formatter.

impl<MSG> PartialEq for Element<MSG>

fn eq(&self, __other: &Element<MSG>) -> 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<MSG> Eq for Element<MSG>