Struct yew::virtual_dom::vtag::VTag

pub struct VTag {
    pub reference: Option<Element>,
    pub listeners: Vec<Rc<dyn Listener>>,
    pub attributes: HashMap<String, String>,
    pub children: VList,
    pub classes: Classes,
    pub value: Option<String>,
    pub kind: Option<String>,
    pub checked: bool,
    pub node_ref: NodeRef,
    // some fields omitted
}

A type for a virtual Element representation.

Fields

reference: Option<Element>

A reference to the Element.

listeners: Vec<Rc<dyn Listener>>

List of attached listeners.

attributes: HashMap<String, String>

List of attributes.

children: VList

List of children nodes

classes: Classes

List of attached classes.

value: Option<String>

Contains a value of an InputElement.

kind: Option<String>

Contains kind value of an InputElement.

checked: bool

Represents checked attribute of input. It exists to override standard behavior of checked attribute, because in original HTML it sets defaultChecked value of InputElement, but for reactive frameworks it's more useful to control checked value of an InputElement.

node_ref: NodeRef

A node reference used for DOM access in Component lifecycle methods

Methods

impl VTag

pub fn new<S: Into<Cow<'static, str>>>(tag: S) -> Self

Creates a new VTag instance with tag name (cannot be changed later in DOM).

pub fn tag(&self) -> &str

Returns tag of an Element. In HTML tags are always uppercase.

pub fn add_child(&mut self, child: VNode)

Add VNode child.

pub fn add_children(&mut self, children: Vec<VNode>)

Add multiple VNode children.

pub fn add_class(&mut self, class: &str)

Adds a single class to this virtual node. Actually it will set by Element.classList.add call later.

pub fn add_classes(&mut self, classes: Vec<&str>)

Adds multiple classes to this virtual node. Actually it will set by Element.classList.add call later.

pub fn set_classes(&mut self, classes: impl Into<Classes>)

Add classes to this virtual node. Actually it will set by Element.classList.add call later.

pub fn set_value<T: ToString>(&mut self, value: &T)

Sets value for an InputElement.

pub fn set_kind<T: ToString>(&mut self, value: &T)

Sets kind property of an InputElement. Same as set type attribute.

pub fn set_checked(&mut self, value: bool)

Sets checked property of an InputElement. (Not a value of node's attribute).

pub fn add_attribute<T: ToString>(&mut self, name: &str, value: &T)

Adds attribute to a virtual node. Not every attribute works when it set as attribute. We use workarounds for: class, type/kind, value and checked.

pub fn add_attributes(&mut self, attrs: Vec<(String, String)>)

Adds attributes to a virtual node. Not every attribute works when it set as attribute. We use workarounds for: class, type/kind, value and checked.

pub fn add_listener(&mut self, listener: Rc<dyn Listener>)

Adds new listener to the node. It's boxed because we want to keep it in a single list. Later Listener::attach will attach an actual listener to a DOM node.

pub fn add_listeners(&mut self, listeners: Vec<Rc<dyn Listener>>)

Adds new listeners to the node. They are boxed because we want to keep them in a single list. Later Listener::attach will attach an actual listener to a DOM node.

Trait Implementations

impl Clone for VTag

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VTag

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

Formats the value using the given formatter.

impl From<VTag> for VNode

fn from(vtag: VTag) -> Self

Performs the conversion.

impl PartialEq<VTag> for VTag

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, T> Transformer<&'a T, T> for VTag where
    T: Clone, 

fn transform(from: &'a T) -> T

Transforms one type to another.

impl<T> Transformer<T, T> for VTag

fn transform(from: T) -> T

Transforms one type to another.

impl VDiff for VTag

fn detach(&mut self, parent: &Element) -> Option<Node>

Remove VTag from parent.

fn apply(
    &mut self,
    parent: &Element,
    previous_sibling: Option<&Node>,
    ancestor: Option<VNode>
) -> Option<Node>

Renders virtual tag over DOM Element, but it also compares this with an ancestor VTag to compute what to patch in the actual DOM nodes.