repose_ui/layout/
engine.rs

1#![allow(non_snake_case)]
2
3use std::cell::RefCell;
4use std::collections::HashMap;
5use std::hash::{Hash, Hasher};
6use std::rc::Rc;
7
8use repose_core::*;
9use repose_tree::{LayoutConstraints, NodeId, ViewTree};
10use rustc_hash::{FxHashMap, FxHasher};
11use taffy::TaffyTree;
12use taffy::prelude::*;
13
14use crate::Interactions;
15use crate::textfield::TextFieldState;
16
17use super::*;
18impl Default for LayoutEngine {
19    fn default() -> Self {
20        Self::new()
21    }
22}
23
24impl LayoutEngine {
25    pub fn layout_frame(
26        &mut self,
27        root: &View,
28        size_px: (u32, u32),
29        textfield_states: &HashMap<u64, Rc<RefCell<TextFieldState>>>,
30        interactions: &Interactions,
31        focused: Option<u64>,
32    ) -> (Scene, Vec<HitRegion>, Vec<SemNode>) {
33        let start = web_time::Instant::now();
34        repose_text::begin_frame();
35        self.stats = LayoutStats::default();
36
37        // 0a. Reset per-frame state
38        self.focus_group_stack.clear();
39
40        // 0b. Check global invalidation
41        let locals_stamp = Self::locals_stamp();
42        let locals_changed = self.last_locals_stamp != Some(locals_stamp);
43        if locals_changed {
44            self.layout_valid = false;
45            self.paint_cache.clear();
46            self.text_cache.clear();
47        }
48
49        // 1. Update tree
50        let density_scale = locals::density().scale.max(0.0001);
51        let max_w_dp = size_px.0 as f32 / density_scale;
52        let max_h_dp = size_px.1 as f32 / density_scale;
53        self.tree
54            .set_subcompose_scope(repose_core::SubcomposeScope::new(
55                0.0, max_w_dp, 0.0, max_h_dp,
56            ));
57        let root_node_id = self.tree.update(root);
58        self.stats.tree = self.tree.stats.clone();
59
60        // 1a. Build scope maps from TreeNode.scope_key (set by scope! macro)
61        self.build_scope_maps();
62
63        // 2. Determine layout need
64        let size_changed = self.last_size_px != Some(size_px);
65        // 2a. Publish the current window size class as a default local so that
66        //     `window_size_class()` returns an up-to-date value even outside
67        //     a `with_window_size_class { ... }` scope. We only touch the
68        //     default when it actually changes to keep the lock uncontended.
69        let density_scale = locals::density().scale * locals::ui_scale().0;
70        let class = locals::calculate_window_size_class(size_px.0, size_px.1, density_scale);
71        if class != locals::window_size_class() {
72            locals::set_window_size_class_default(class);
73        }
74        let inv_density = if density_scale > 0.0 {
75            1.0 / density_scale
76        } else {
77            1.0
78        };
79        locals::set_window_container_size(
80            size_px.0 as f32 * inv_density,
81            size_px.1 as f32 * inv_density,
82        );
83        let has_tree_mutation =
84            !self.tree.dirty_nodes().is_empty() || !self.tree.removed_ids.is_empty();
85        let need_layout = size_changed || !self.layout_valid || has_tree_mutation || locals_changed;
86
87        // NOTE: Needed to ensure that text is always re-measured with the new available width
88        if size_changed {
89            // Root tree text cache
90            for &node_id in self.text_cache.keys() {
91                if let Some(&taffy_id) = self.taffy_map.get(&node_id) {
92                    let _ = self.taffy.mark_dirty(taffy_id);
93                }
94            }
95            self.text_cache.clear();
96            // Scope tree text caches
97            for st in self.scope_trees.values_mut() {
98                for &node_id in st.text_cache.keys() {
99                    if let Some(&tid) = st.taffy_map.get(&node_id) {
100                        let _ = st.taffy.mark_dirty(tid);
101                    }
102                }
103                st.text_cache.clear();
104            }
105        }
106        if locals_changed {
107            for st in self.scope_trees.values_mut() {
108                st.text_cache.clear();
109            }
110        }
111
112        // Helpers
113        let px = |dp_val: f32| dp_to_px(dp_val);
114        let font_px = |dp_font: f32| dp_to_px(dp_font) * locals::text_scale().0;
115
116        // 3. Sync Taffy
117        // 3a. Sync scope-internal TaffyTrees first
118        self.sync_scope_trees(&font_px);
119        // 3b. Sync root TaffyTree (non-scope nodes + scope root markers)
120        self.sync_taffy_tree(root_node_id, &font_px);
121
122        // 4. Compute Layout
123        let taffy_root = self.taffy_map.get(&root_node_id).copied();
124        if let Some(taffy_root) = taffy_root {
125            if need_layout {
126                if let Ok(mut style) = self.taffy.style(taffy_root).cloned() {
127                    style.size.width = length(size_px.0 as f32);
128                    style.size.height = length(size_px.1 as f32);
129                    let _ = self.taffy.set_style(taffy_root, style);
130                }
131
132                let available = taffy::geometry::Size {
133                    width: AvailableSpace::Definite(size_px.0 as f32),
134                    height: AvailableSpace::Definite(size_px.1 as f32),
135                };
136
137                Self::run_measure_pass(
138                    &mut self.taffy,
139                    taffy_root,
140                    available,
141                    &self.tree,
142                    &mut self.text_cache,
143                    &self.reverse_map,
144                    &self.scope_root_map,
145                    &self.node_to_scope,
146                    &mut self.scope_trees,
147                    &font_px,
148                    &px,
149                );
150
151                // 4a. Store Taffy-computed sizes for non-scope + scope-root nodes
152                for (&node_id, &taffy_id) in &self.taffy_map {
153                    if let Ok(layout) = self.taffy.layout(taffy_id) {
154                        let dp_w = layout.size.width / density_scale;
155                        let dp_h = layout.size.height / density_scale;
156                        let rect = repose_core::Rect {
157                            x: 0.0,
158                            y: 0.0,
159                            w: dp_w,
160                            h: dp_h,
161                        };
162                        self.tree
163                            .set_layout(node_id, rect, rect, LayoutConstraints::default());
164                    }
165                }
166
167                self.last_locals_stamp = Some(locals_stamp);
168
169                self.layout_valid = true;
170                self.last_size_px = Some(size_px);
171                self.stats.layout_misses += 1;
172            } else {
173                self.stats.layout_hits += 1;
174            }
175        }
176        self.stats.layout_time_ms = (web_time::Instant::now() - start).as_secs_f32() * 1000.0;
177
178        // 4.5. Advance scroll physics (pre-paint, so paint only reads offset)
179        self.walk_tick(root_node_id);
180
181        // 5. Paint
182        let t_paint = web_time::Instant::now();
183        let (scene, hits, sems) = self.paint(
184            root_node_id,
185            textfield_states,
186            interactions,
187            focused,
188            &font_px,
189        );
190        self.stats.paint_time_ms = (web_time::Instant::now() - t_paint).as_secs_f32() * 1000.0;
191
192        // Fire focus change callbacks
193        if self.prev_focused != focused {
194            if let Some(old_id) = self.prev_focused
195                && let Some(cb) = self.focus_callbacks.get(&old_id)
196            {
197                (cb)(false);
198            }
199            if let Some(new_id) = focused
200                && let Some(cb) = self.focus_callbacks.get(&new_id)
201            {
202                (cb)(true);
203            }
204            self.prev_focused = focused;
205        }
206
207        // Clean up callbacks for removed nodes
208        for &node_id in &self.tree.removed_ids {
209            if let Some(&vid) = self.view_ids.get(&node_id) {
210                self.focus_callbacks.remove(&vid);
211            }
212        }
213
214        self.tree.clear_dirty();
215        (scene, hits, sems)
216    }
217
218    pub fn intrinsic_size(&mut self, view: &View, mode: IntrinsicSizeMode) -> (f32, f32) {
219        let px_closure = |dp_val: f32| dp_to_px(dp_val);
220        let font_px_closure = |dp_font: f32| dp_to_px(dp_font) * locals::text_scale().0;
221
222        let mut temp_taffy = taffy::TaffyTree::new();
223        let root_tid = self.build_taffy_subtree(view, &mut temp_taffy, &font_px_closure);
224
225        let avail = match mode {
226            IntrinsicSizeMode::MinContent => taffy::geometry::Size {
227                width: taffy::style::AvailableSpace::MinContent,
228                height: taffy::style::AvailableSpace::MinContent,
229            },
230            IntrinsicSizeMode::MaxContent => taffy::geometry::Size {
231                width: taffy::style::AvailableSpace::MaxContent,
232                height: taffy::style::AvailableSpace::MaxContent,
233            },
234        };
235
236        let mut text_cache: FxHashMap<NodeId, TextLayout> = FxHashMap::default();
237        let reverse_map: FxHashMap<taffy::NodeId, NodeId> = FxHashMap::default();
238
239        Self::run_measure_pass(
240            &mut temp_taffy,
241            root_tid,
242            avail,
243            &self.tree,
244            &mut text_cache,
245            &reverse_map,
246            &self.scope_root_map,
247            &self.node_to_scope,
248            &mut self.scope_trees,
249            &font_px_closure,
250            &px_closure,
251        );
252
253        let layout = temp_taffy.layout(root_tid).ok();
254        match layout {
255            Some(l) => (l.size.width, l.size.height),
256            None => (0.0, 0.0),
257        }
258    }
259
260    pub fn new() -> Self {
261        Self {
262            tree: ViewTree::new(),
263            taffy: TaffyTree::new(),
264            taffy_map: FxHashMap::default(),
265            reverse_map: FxHashMap::default(),
266            scope_trees: HashMap::new(),
267            scope_root_map: FxHashMap::default(),
268            node_to_scope: FxHashMap::default(),
269            text_cache: FxHashMap::default(),
270            last_size_px: None,
271            layout_valid: false,
272            paint_cache: FxHashMap::default(),
273            stats: LayoutStats::default(),
274            last_locals_stamp: None,
275            view_ids: FxHashMap::default(),
276            next_view_id: 1,
277            layer_id_counter: 0,
278            prev_focused: None,
279            focus_callbacks: FxHashMap::default(),
280            prev_observed_rects: FxHashMap::default(),
281            focus_group_stack: Vec::new(),
282        }
283    }
284
285    pub(crate) fn layout_for_node(&self, node_id: NodeId) -> taffy::prelude::Layout {
286        // Scope root nodes: use the root tree layout (has correct position + size after flexbox resolve).
287        // Their children use the scope tree layout (positions relative to scope root).
288        if self.scope_root_map.contains_key(&node_id) {
289            if let Some(&tid) = self.taffy_map.get(&node_id) {
290                return *self.taffy.layout(tid).unwrap();
291            }
292            // Nested scope root: the enclosing scope positions it via a leaf
293            // marker; inherit that layout so the subtree paints at the right
294            // spot instead of the nested scope's origin.
295            if let Some(parent_id) = self.tree.get(node_id).and_then(|n| n.parent)
296                && let Some(outer_key) = self.node_to_scope.get(&parent_id)
297                && let Some(st) = self.scope_trees.get(outer_key)
298                && let Some(&tid) = st.taffy_map.get(&node_id)
299            {
300                return *st.taffy.layout(tid).unwrap();
301            }
302            if let Some(key) = self.node_to_scope.get(&node_id)
303                && let Some(st) = self.scope_trees.get(key)
304                && let Some(&tid) = st.taffy_map.get(&node_id)
305            {
306                return *st.taffy.layout(tid).unwrap();
307            }
308        }
309        if let Some(key) = self.node_to_scope.get(&node_id)
310            && let Some(st) = self.scope_trees.get(key)
311        {
312            let tid = st.taffy_map[&node_id];
313            return *st.taffy.layout(tid).unwrap();
314        }
315        let tid = self.taffy_map[&node_id];
316        *self.taffy.layout(tid).unwrap()
317    }
318
319    pub(crate) fn taffy_children_for_node(&self, node_id: NodeId) -> Vec<taffy::NodeId> {
320        if let Some(key) = self.node_to_scope.get(&node_id)
321            && let Some(st) = self.scope_trees.get(key)
322        {
323            let tid = st.taffy_map[&node_id];
324            return st.taffy.children(tid).unwrap_or_default();
325        }
326        let tid = self.taffy_map[&node_id];
327        self.taffy.children(tid).unwrap_or_default()
328    }
329
330    pub(crate) fn ensure_view_id(&mut self, node_id: NodeId) -> u64 {
331        if let Some(&id) = self.view_ids.get(&node_id) {
332            return id;
333        }
334        let id = self.next_view_id;
335        self.next_view_id += 1;
336        self.view_ids.insert(node_id, id);
337        id
338    }
339
340    pub(crate) fn locals_stamp() -> u64 {
341        let mut h = FxHasher::default();
342
343        // These affect layout measurement and/or flex direction decisions.
344        locals::density().scale.to_bits().hash(&mut h);
345        locals::text_scale().0.to_bits().hash(&mut h);
346
347        let dir_u8 = match locals::text_direction() {
348            locals::TextDirection::Ltr => 0u8,
349            locals::TextDirection::Rtl => 1u8,
350        };
351        dir_u8.hash(&mut h);
352
353        h.finish()
354    }
355}
repose_ui/layout/engine.rs

repose_ui/layout/
engine.rs
