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
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::cell::RefCell;
use std::collections::VecDeque;
use std::rc::Rc;
use futures::executor::block_on;

use super::{Component, PrerenderableComponent, ComponentRc};
use super::backend::*;
use super::node::*;
use super::prerender::{match_prerendered_tree};

pub struct Context<B: Backend> {
    group_holder: VirtualNodeRc<B>,
    root: Option<ComponentNodeRc<B>>,
    backend: Rc<B>,
    scheduler: Rc<Scheduler>,
}

impl<B: Backend> Context<B> {
    pub fn new(backend: B) -> Context<B> {
        let backend = Rc::new(backend);
        let ret = Self {
            group_holder: VirtualNodeRc::new_with_me_cell_group(
                VirtualNode::new_empty(backend.clone())
            ),
            root: None,
            backend,
            scheduler: Rc::new(Scheduler::new()),
        };
        ret
    }
    pub fn new_prerendered<'a, 'b: 'a, C: 'static + PrerenderableComponent<'a, B>>(backend: B, prerendered_data: &'b [u8]) -> Context<B> {
        let backend = Rc::new(backend);
        if !backend.is_prerendering() {
            panic!("the backend is not in prerendering progress");
        }
        let group_holder = VirtualNodeRc::new_with_me_cell_group(
            VirtualNode::new_empty(backend.clone())
        );
        let scheduler = Rc::new(Scheduler::new());
        let prerendered_data: C::PrerenderedData = bincode::deserialize(&prerendered_data).unwrap();
        let root = create_component::<_, _, C>(&mut group_holder.borrow_mut(), scheduler.clone(), "maomi", vec![], None).with_type::<C>();
        backend.set_root_node(&root.borrow().backend_element());
        {
            let mut root = root.borrow_mut();
            <C as PrerenderableComponent<'_, B>>::apply_prerendered_data(&mut root, &prerendered_data);
            root.apply_updates();
            match_prerendered_tree(root.as_node().duplicate(), &backend);
            backend.end_prerendering();
            root.as_node().set_attached();
        }
        let root = root.into_node();
        let ret = Self {
            group_holder,
            root: Some(root),
            backend,
            scheduler,
        };
        ret
    }
    pub fn prerender<'a, C: 'static + PrerenderableComponent<'a, B>>(backend: B) -> (Context<B>, Vec<u8>) {
        let backend = Rc::new(backend);
        if backend.is_prerendering() {
            panic!("the backend is already in prerendering progress");
        }
        let group_holder = VirtualNodeRc::new_with_me_cell_group(
            VirtualNode::new_empty(backend.clone())
        );
        let scheduler = Rc::new(Scheduler::new());
        let root = create_component::<_, _, C>(&mut group_holder.borrow_mut(), scheduler.clone(), "maomi", vec![], None).with_type::<C>();
        let prerendered_data = {
            let mut root = root.borrow_mut();
            let prerendered_data = block_on(<C as PrerenderableComponent<'_, B>>::get_prerendered_data(&mut root));
            <C as PrerenderableComponent<'_, B>>::apply_prerendered_data(&mut root, &prerendered_data);
            root.apply_updates();
            prerendered_data
        };
        let root = root.into_node();
        let ret = Self {
            group_holder,
            root: Some(root),
            backend,
            scheduler,
        };
        (ret, bincode::serialize(&prerendered_data).unwrap())
    }
    pub fn backend(&self) -> &B {
        &self.backend
    }
    pub fn root_component<C: 'static + Component<B>>(&self) -> Option<ComponentRc<B, C>> {
        self.root.clone().map(|x| {
            x.with_type::<C>()
        })
    }
    pub fn new_root_component<C: 'static + Component<B>>(&mut self) -> ComponentRc<B, C> {
        let ret = create_component::<_, _, C>(&mut self.group_holder.borrow_mut(), self.scheduler.clone(), "maomi", vec![], None).with_type::<C>();
        ret
    }
    pub fn set_root_component<C: 'static + Component<B>>(&mut self, component_node: ComponentRc<B, C>) {
        if let Some(old_root) = self.root.take() {
            old_root.borrow_mut().set_detached();
        }
        self.root = Some(component_node.as_node().clone());
        self.backend.set_root_node(&self.root.as_ref().unwrap().borrow_mut().backend_element);
        component_node.as_node().borrow_mut().set_attached();
    }
}

pub(crate) struct Scheduler {
    pending_tasks: RefCell<VecDeque<Box<dyn FnOnce()>>>,
}

impl Scheduler {
    fn new() -> Self {
        Self {
            pending_tasks: RefCell::new(VecDeque::new())
        }
    }
    pub(crate) fn add_task<F: 'static + FnOnce()>(&self, task: F) {
        self.pending_tasks.borrow_mut().push_back(Box::new(task));
    }
    pub(crate) fn run_tasks(&self) {
        loop {
            let task = self.pending_tasks.borrow_mut().pop_front();
            match task {
                None => break,
                Some(x) => x(),
            }
        }
    }
}