Skip to main content

xrack_runtime/
repeat.rs

1use crate::{
2    ChangeSignal, ListModel, Node, Property, RowContext, RowKey, TableColumnWindow,
3    list::{try_render_rows_from_source, try_render_stable_rows},
4};
5use std::{
6    cell::RefCell,
7    collections::{BTreeMap, BTreeSet},
8    ops::Range,
9    rc::Rc,
10};
11
12/// Build a scene for a compiler-proven static integer repeat.
13#[doc(hidden)]
14pub fn static_repeat_scene(template: Node, count: i64, positioned: bool) -> Node {
15    let template = template.into_shared();
16    let children = (0..count.row_count())
17        .map(|index| {
18            let mut row = template.clone();
19            row.set_row_key(Some(count.row_key(index)));
20            row
21        })
22        .collect();
23    repeat_scene(children, positioned).into_shared()
24}
25
26/// Wrap the materialized rows of an ordinary repeat in their scene container.
27#[doc(hidden)]
28pub fn repeat_scene(children: Vec<Node>, positioned: bool) -> Node {
29    if children.is_empty() {
30        return Node::hidden();
31    }
32    let kind = if positioned {
33        "Rectangle"
34    } else {
35        "VerticalLayout"
36    };
37    let mut scene = Node::new(kind, None);
38    scene.children = children;
39    scene
40}
41
42struct Row<Model: ListModel, State> {
43    synchronize: Property<()>,
44    model: Property<Rc<Model>>,
45    context: RowContext<Model::Item>,
46    state: State,
47    scene: Property<Node>,
48}
49
50impl<Model: ListModel, State: Default> Row<Model, State> {
51    fn new(index: usize, key: RowKey) -> Self {
52        Self {
53            synchronize: Property::default(),
54            model: Property::default(),
55            context: RowContext::new(key, index),
56            state: State::default(),
57            scene: Property::default(),
58        }
59    }
60}
61
62impl<Model: ListModel, State> Row<Model, State> {
63    fn sync(&self, model: &Rc<Model>, index: usize, key: RowKey) {
64        self.context.set_key(key);
65        self.model.set_if_changed_by(model.clone(), Rc::ptr_eq);
66        self.synchronize.get(|| {
67            let model = self
68                .model
69                .get(|| unreachable!("repeat model is initialized"));
70            self.context.set_item(model.item(index));
71        });
72    }
73}
74
75/// Scene and binding caches scoped to each position in a generated repeat.
76pub struct Repeater<Model: ListModel, State> {
77    rows: RefCell<BTreeMap<usize, Rc<Row<Model, State>>>>,
78    model: Property<Rc<Model>>,
79    columns: RefCell<TableColumnWindow>,
80    columns_changed: ChangeSignal,
81}
82
83impl<Model: ListModel, State> Default for Repeater<Model, State> {
84    fn default() -> Self {
85        Self {
86            rows: RefCell::default(),
87            model: Property::default(),
88            columns: RefCell::default(),
89            columns_changed: ChangeSignal::default(),
90        }
91    }
92}
93
94impl<Model: ListModel, State: Default> Repeater<Model, State> {
95    #[doc(hidden)]
96    pub fn column_window(&self, columns: &TableColumnWindow) -> &ChangeSignal {
97        if &*self.columns.borrow() != columns {
98            self.columns.replace(columns.clone());
99            self.columns_changed.notify();
100        }
101        &self.columns_changed
102    }
103
104    pub fn resolve_model(&self, model: impl FnOnce() -> Model) -> Rc<Model> {
105        self.model.get(|| Rc::new(model()))
106    }
107    pub fn with_model<R>(
108        &self,
109        model: impl FnOnce() -> Model,
110        read: impl FnOnce(&Model) -> R,
111    ) -> R {
112        read(&self.model.get(|| Rc::new(model())))
113    }
114
115    #[doc(hidden)]
116    pub fn with_row_state<R>(
117        &self,
118        model: impl FnOnce() -> Model,
119        index: usize,
120        key: RowKey,
121        read: impl FnOnce(&dyn Fn() -> Model::Item, &dyn Fn() -> i64, &State) -> R,
122    ) -> Option<R> {
123        let model = self.resolve_model(model);
124        self.with_resolved_row_state(&model, index, key, read)
125    }
126
127    #[doc(hidden)]
128    pub fn with_resolved_row_state<R>(
129        &self,
130        model: &Rc<Model>,
131        index: usize,
132        key: RowKey,
133        read: impl FnOnce(&dyn Fn() -> Model::Item, &dyn Fn() -> i64, &State) -> R,
134    ) -> Option<R> {
135        let index = model.event_row_index(index, key, false)?;
136        let row = self
137            .rows
138            .borrow()
139            .get(&index)
140            .cloned()
141            .unwrap_or_else(|| Rc::new(Row::new(index, key)));
142        crate::property::without_read_watches(|| row.sync(model, index, key));
143        Some(read(&|| row.context.item(), &|| index as i64, &row.state))
144    }
145
146    /// Access a materialized row after confirming the displayed key still matches.
147    #[doc(hidden)]
148    pub fn with_resolved_row<R>(
149        &self,
150        model: &Rc<Model>,
151        index: usize,
152        key: RowKey,
153        read: impl FnOnce(&State) -> R,
154    ) -> Option<R> {
155        let index = model.event_row_index(index, key, false)?;
156        let row = self.rows.borrow().get(&index).cloned()?;
157        crate::property::without_read_watches(|| row.sync(model, index, key));
158        Some(read(&row.state))
159    }
160
161    pub fn row_count(&self, model: impl FnOnce() -> Model) -> usize {
162        self.model.get(|| Rc::new(model())).row_count()
163    }
164
165    pub fn render(
166        &self,
167        model: impl Fn() -> Model,
168        render_row: impl Fn(usize, &dyn Fn() -> Model::Item, &State) -> Node,
169    ) -> Node {
170        repeat_scene(self.render_range(model, 0..4096, render_row), false)
171    }
172
173    #[doc(hidden)]
174    pub fn render_positioned(
175        &self,
176        model: impl Fn() -> Model,
177        render_row: impl Fn(usize, &dyn Fn() -> Model::Item, &State) -> Node,
178    ) -> Node {
179        repeat_scene(self.render_range(model, 0..4096, render_row), true)
180    }
181
182    pub fn render_range(
183        &self,
184        model: impl Fn() -> Model,
185        range: Range<usize>,
186        render_row: impl Fn(usize, &dyn Fn() -> Model::Item, &State) -> Node,
187    ) -> Vec<Node> {
188        try_render_rows_from_source(
189            || Ok(self.resolve_model(model)),
190            |resolved| {
191                let range = range.start..range.end.min(resolved.row_count());
192                self.rows
193                    .borrow_mut()
194                    .retain(|index, _| range.contains(index));
195                self.try_render_rows(&resolved, range, |index, context, state| {
196                    Ok::<_, std::convert::Infallible>(render_row(index, &|| context.item(), state))
197                })
198            },
199        )
200        .unwrap_or_else(|error| match error {})
201    }
202
203    pub fn render_indices(
204        &self,
205        model: impl Fn() -> Model,
206        indices: impl IntoIterator<Item = usize>,
207        render_row: impl Fn(usize, &dyn Fn() -> Model::Item, &State) -> Node,
208    ) -> Vec<Node> {
209        try_render_rows_from_source(
210            || Ok::<_, std::convert::Infallible>(self.resolve_model(model)),
211            |resolved| Ok(self.render_resolved_indices(&resolved, indices, render_row)),
212        )
213        .unwrap_or_else(|error| match error {})
214    }
215
216    #[doc(hidden)]
217    pub fn render_resolved_indices(
218        &self,
219        resolved: &Rc<Model>,
220        indices: impl IntoIterator<Item = usize>,
221        render_row: impl Fn(usize, &dyn Fn() -> Model::Item, &State) -> Node,
222    ) -> Vec<Node> {
223        self.try_render_resolved_indices(resolved, indices, |index, context, state| {
224            Ok::<_, std::convert::Infallible>(render_row(index, &|| context.item(), state))
225        })
226        .unwrap_or_else(|error| match error {})
227    }
228
229    /// Cache only successful renders, retaining bindings at positions that remain visible.
230    #[doc(hidden)]
231    pub fn try_render_resolved_indices<E>(
232        &self,
233        resolved: &Rc<Model>,
234        indices: impl IntoIterator<Item = usize>,
235        render_row: impl Fn(usize, &RowContext<Model::Item>, &State) -> Result<Node, E>,
236    ) -> Result<Vec<Node>, E> {
237        let count = resolved.row_count();
238        let indices: Vec<_> = indices.into_iter().filter(|&index| index < count).collect();
239        let retained: BTreeSet<_> = indices.iter().copied().collect();
240        self.rows
241            .borrow_mut()
242            .retain(|index, _| retained.contains(index));
243        self.try_render_rows(resolved, indices, render_row)
244    }
245
246    fn try_render_rows<E>(
247        &self,
248        resolved: &Rc<Model>,
249        indices: impl IntoIterator<Item = usize>,
250        render_row: impl Fn(usize, &RowContext<Model::Item>, &State) -> Result<Node, E>,
251    ) -> Result<Vec<Node>, E> {
252        try_render_stable_rows(
253            resolved.as_ref(),
254            resolved.structure_stamp(),
255            indices,
256            |index| {
257                let key = resolved.row_key(index);
258                let row = self
259                    .rows
260                    .borrow_mut()
261                    .entry(index)
262                    .or_insert_with(|| Rc::new(Row::new(index, key)))
263                    .clone();
264                row.sync(resolved, index, key);
265                let mut node = row
266                    .scene
267                    .try_get(|| render_row(index, &row.context, &row.state))?;
268                node.set_row_key(Some(key));
269                Ok(node)
270            },
271        )
272    }
273}