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#[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#[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
75pub 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 #[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 #[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}