workflow-html 0.19.0

HTML templating engine for run-time DOM injections
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use crate::WebElement;
use crate::render::{Render, Renderables};
pub use crate::utils::{Element, ElementResult, document};
use std::collections::BTreeMap;
/// Map of `@name`-tagged element bindings keyed by their declared name.
pub type Hooks = BTreeMap<String, Element>;
//use workflow_log::log_trace;

/// The result of rendering an HTML template: the live DOM root elements, the
/// map of `@name`-tagged hook elements, and the retained Rust renderables that
/// keep elements and callbacks alive for the lifetime of this structure.
#[derive(Clone)]
pub struct Html {
    /// The top-level DOM elements produced by the template.
    pub roots: Vec<Element>,
    /// Map of `@name`-tagged elements available for external binding.
    pub hooks: Hooks,
    /// Retained renderables that keep DOM elements and Rust state alive.
    pub renderables: Renderables,
}

impl Html {
    /// Constructs an [`Html`] from its rendered root elements, hooks map and
    /// retained renderables.
    pub fn new(roots: Vec<Element>, hooks: Hooks, renderables: Renderables) -> ElementResult<Html> {
        let html = Html {
            roots,
            hooks,
            renderables,
        };
        Ok(html)
    }

    /// Returns the top-level DOM elements produced by the template.
    pub fn roots(&self) -> &Vec<Element> {
        &self.roots
    }

    /// Returns the map of `@name`-tagged elements available for external binding.
    pub fn hooks(&self) -> &Hooks {
        &self.hooks
    }

    /// Appends each root element into the given parent DOM `element`.
    pub fn inject_into(&self, element: &Element) -> ElementResult<()> {
        for root in self.roots.iter() {
            element.append_child(root)?;
        }
        Ok(())
    }
    /// Removes all event listeners from every retained renderable, releasing
    /// their closures.
    pub fn remove_event_listeners(&self) -> ElementResult<()> {
        for root in &self.renderables {
            root.remove_event_listeners()?;
        }
        Ok(())
    }
}

impl Render for Html {
    fn render_node(
        mut self,
        parent: &mut WebElement,
        map: &mut Hooks,
        renderables: &mut Renderables,
    ) -> ElementResult<()> {
        renderables.append(self.renderables.as_mut());
        let mut hooks = self.hooks().clone();
        map.append(&mut hooks);
        self.inject_into(parent)?;
        Ok(())
    }

    fn render(&self, _w: &mut Vec<String>) -> ElementResult<()> {
        Ok(())
    }

    fn remove_event_listeners(&self) -> ElementResult<()> {
        for root in &self.renderables {
            root.remove_event_listeners()?;
        }
        Ok(())
    }
}

/*
impl Drop for Html{
    fn drop(&mut self) {
        log_trace!("HTML Drop: {:?}", self.roots[0].get_attribute("class"));
    }
}
*/