cranpose 0.9.22

Build desktop, mobile and web apps with composable Rust functions
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
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

use std::sync::mpsc::{self, Receiver, Sender};

use cranpose_ui::{LayoutTree, Rect};

use crate::native_view::NativeViewHost;

pub(crate) type Events = Sender<(u64, String)>;

pub(crate) trait BrowserView {
    fn navigate(&mut self, url: &str) -> Result<(), String>;
    fn place(&mut self, bounds: Rect) -> Result<(), String>;
}

struct Child<V> {
    id: u64,
    url: String,
    bounds: Rect,
    view: Option<V>,
    seen: bool,
}

pub(crate) struct WebViews<V> {
    children: Vec<Child<V>>,
    revision: u64,
    pub(crate) events: Events,
    incoming: Receiver<(u64, String)>,
}

impl<V> Default for WebViews<V> {
    fn default() -> Self {
        let (events, incoming) = mpsc::channel();
        Self {
            children: Vec::new(),
            revision: 0,
            events,
            incoming,
        }
    }
}

impl<V: BrowserView> WebViews<V> {
    #[cfg(target_os = "ios")]
    pub(crate) fn revision(&self) -> u64 {
        self.revision
    }

    #[cfg(any(target_os = "ios", target_os = "linux"))]
    pub(crate) fn views(&self) -> impl Iterator<Item = &V> {
        self.children.iter().filter_map(|child| child.view.as_ref())
    }
    pub(crate) fn dispatch(&self, host: &NativeViewHost) {
        for (id, event) in self.incoming.try_iter() {
            host.dispatch(id, &event);
        }
    }

    pub(crate) fn is_empty(&self) -> bool {
        self.children.is_empty()
    }

    pub(crate) fn sync(
        &mut self,
        host: &NativeViewHost,
        tree: Option<&LayoutTree>,
        mut create: impl FnMut(u64, &str, Rect, &Events) -> Result<V, String>,
    ) {
        if host.is_empty() && self.is_empty() {
            return;
        }
        for child in &mut self.children {
            child.seen = false;
        }
        host.for_each_layout(tree, |id, kind, url, bounds| {
            if kind != "web" {
                return;
            }
            if let Some(child) = self.children.iter_mut().find(|child| child.id == id) {
                child.seen = true;
                if let Some(view) = &mut child.view {
                    if child.url != url {
                        if let Err(error) = view.navigate(url) {
                            let _ = self.events.send((id, format!("error:{error}")));
                        }
                        url.clone_into(&mut child.url);
                    }
                    if child.bounds != bounds {
                        if let Err(error) = view.place(bounds) {
                            let _ = self.events.send((id, format!("error:{error}")));
                        }
                        child.bounds = bounds;
                    }
                }
                return;
            }
            let view = match create(id, url, bounds, &self.events) {
                Ok(view) => Some(view),
                Err(error) => {
                    let _ = self.events.send((id, format!("error:{error}")));
                    None
                }
            };
            self.children.push(Child {
                id,
                url: url.to_owned(),
                bounds,
                view,
                seen: true,
            });
            self.revision = self.revision.wrapping_add(1);
        });
        let before = self.children.len();
        self.children.retain(|child| child.seen);
        if before != self.children.len() {
            self.revision = self.revision.wrapping_add(1);
        }
        self.dispatch(host);
    }
}