Split out caching into separate `CacheTree` trait (#758)
1mod common {
2 pub mod image;
3 pub mod text;
4}
5use common::image::{image_measure_function, ImageContext};
6use common::text::{text_measure_function, FontMetrics, TextContext, WritingMode, LOREM_IPSUM};
7use taffy::tree::Cache;
8use taffy::util::print_tree;
9use taffy::{
10 compute_cached_layout, compute_flexbox_layout, compute_grid_layout, compute_leaf_layout, compute_root_layout,
11 prelude::*, round_layout, CacheTree,
12};
13
14#[derive(Debug, Copy, Clone)]
15#[allow(dead_code)]
16enum NodeKind {
17 Flexbox,
18 Grid,
19 Text,
20 Image,
21}
22
23struct Node {
24 kind: NodeKind,
25 style: Style,
26 text_data: Option<TextContext>,
27 image_data: Option<ImageContext>,
28 cache: Cache,
29 unrounded_layout: Layout,
30 final_layout: Layout,
31 children: Vec<Node>,
32}
33
34impl Default for Node {
35 fn default() -> Self {
36 Node {
37 kind: NodeKind::Flexbox,
38 style: Style::default(),
39 text_data: None,
40 image_data: None,
41 cache: Cache::new(),
42 unrounded_layout: Layout::with_order(0),
43 final_layout: Layout::with_order(0),
44 children: Vec::new(),
45 }
46 }
47}
48
49#[allow(dead_code)]
50impl Node {
51 pub fn new_row(style: Style) -> Node {
52 Node {
53 kind: NodeKind::Flexbox,
54 style: Style { display: Display::Flex, flex_direction: FlexDirection::Row, ..style },
55 ..Node::default()
56 }
57 }
58 pub fn new_column(style: Style) -> Node {
59 Node {
60 kind: NodeKind::Flexbox,
61 style: Style { display: Display::Flex, flex_direction: FlexDirection::Column, ..style },
62 ..Node::default()
63 }
64 }
65 pub fn new_grid(style: Style) -> Node {
66 Node { kind: NodeKind::Grid, style: Style { display: Display::Grid, ..style }, ..Node::default() }
67 }
68 pub fn new_text(style: Style, text_data: TextContext) -> Node {
69 Node { kind: NodeKind::Text, style, text_data: Some(text_data), ..Node::default() }
70 }
71 pub fn new_image(style: Style, image_data: ImageContext) -> Node {
72 Node { kind: NodeKind::Image, style, image_data: Some(image_data), ..Node::default() }
73 }
74 pub fn append_child(&mut self, node: Node) {
75 self.children.push(node);
76 }
77
78 unsafe fn as_id(&self) -> NodeId {
79 NodeId::from(self as *const Node as usize)
80 }
81
82 pub fn compute_layout(&mut self, available_space: Size<AvailableSpace>, use_rounding: bool) {
83 let root_node_id = unsafe { self.as_id() };
84 compute_root_layout(&mut StatelessLayoutTree, root_node_id, available_space);
85 if use_rounding {
86 round_layout(&mut StatelessLayoutTree, root_node_id)
87 }
88 }
89
90 pub fn print_tree(&mut self) {
91 print_tree(&StatelessLayoutTree, unsafe { self.as_id() });
92 }
93}
94
95struct ChildIter<'a>(std::slice::Iter<'a, Node>);
96impl Iterator for ChildIter<'_> {
97 type Item = NodeId;
98 fn next(&mut self) -> Option<Self::Item> {
99 self.0.next().map(|c| NodeId::from(c as *const Node as usize))
100 }
101}
102
103#[inline(always)]
104unsafe fn node_from_id<'a>(node_id: NodeId) -> &'a Node {
105 &*(usize::from(node_id) as *const Node)
106}
107
108#[inline(always)]
109unsafe fn node_from_id_mut<'a>(node_id: NodeId) -> &'a mut Node {
110 &mut *(usize::from(node_id) as *mut Node)
111}
112
113struct StatelessLayoutTree;
114impl TraversePartialTree for StatelessLayoutTree {
115 type ChildIter<'a> = ChildIter<'a>;
116
117 fn child_ids(&self, node_id: NodeId) -> Self::ChildIter<'_> {
118 unsafe { ChildIter(node_from_id(node_id).children.iter()) }
119 }
120
121 fn child_count(&self, node_id: NodeId) -> usize {
122 unsafe { node_from_id(node_id).children.len() }
123 }
124
125 fn get_child_id(&self, node_id: NodeId, index: usize) -> NodeId {
126 unsafe { node_from_id(node_id).children[index].as_id() }
127 }
128}
129
130impl TraverseTree for StatelessLayoutTree {}
131
132impl LayoutPartialTree for StatelessLayoutTree {
133 type CoreContainerStyle<'a>
134 = &'a Style
135 where
136 Self: 'a;
137
138 fn get_core_container_style(&self, node_id: NodeId) -> Self::CoreContainerStyle<'_> {
139 unsafe { &node_from_id(node_id).style }
140 }
141
142 fn set_unrounded_layout(&mut self, node_id: NodeId, layout: &Layout) {
143 unsafe { node_from_id_mut(node_id).unrounded_layout = *layout };
144 }
145
146 fn compute_child_layout(&mut self, node_id: NodeId, inputs: taffy::tree::LayoutInput) -> taffy::tree::LayoutOutput {
147 compute_cached_layout(self, node_id, inputs, |tree, node_id, inputs| {
148 let node = unsafe { node_from_id_mut(node_id) };
149 let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };
150
151 match node.kind {
152 NodeKind::Flexbox => compute_flexbox_layout(tree, node_id, inputs),
153 NodeKind::Grid => compute_grid_layout(tree, node_id, inputs),
154 NodeKind::Text => compute_leaf_layout(inputs, &node.style, |known_dimensions, available_space| {
155 text_measure_function(
156 known_dimensions,
157 available_space,
158 node.text_data.as_ref().unwrap(),
159 &font_metrics,
160 )
161 }),
162 NodeKind::Image => compute_leaf_layout(inputs, &node.style, |known_dimensions, _available_space| {
163 image_measure_function(known_dimensions, node.image_data.as_ref().unwrap())
164 }),
165 }
166 })
167 }
168}
169
170impl CacheTree for StatelessLayoutTree {
171 fn cache_get(
172 &self,
173 node_id: NodeId,
174 known_dimensions: Size<Option<f32>>,
175 available_space: Size<AvailableSpace>,
176 run_mode: taffy::RunMode,
177 ) -> Option<taffy::LayoutOutput> {
178 unsafe { node_from_id(node_id) }.cache.get(known_dimensions, available_space, run_mode)
179 }
180
181 fn cache_store(
182 &mut self,
183 node_id: NodeId,
184 known_dimensions: Size<Option<f32>>,
185 available_space: Size<AvailableSpace>,
186 run_mode: taffy::RunMode,
187 layout_output: taffy::LayoutOutput,
188 ) {
189 unsafe { node_from_id_mut(node_id) }.cache.store(known_dimensions, available_space, run_mode, layout_output)
190 }
191
192 fn cache_clear(&mut self, node_id: NodeId) {
193 unsafe { node_from_id_mut(node_id) }.cache.clear()
194 }
195}
196
197impl taffy::LayoutFlexboxContainer for StatelessLayoutTree {
198 type FlexboxContainerStyle<'a>
199 = &'a Style
200 where
201 Self: 'a;
202
203 type FlexboxItemStyle<'a>
204 = &'a Style
205 where
206 Self: 'a;
207
208 fn get_flexbox_container_style(&self, node_id: NodeId) -> Self::FlexboxContainerStyle<'_> {
209 unsafe { &node_from_id(node_id).style }
210 }
211
212 fn get_flexbox_child_style(&self, child_node_id: NodeId) -> Self::FlexboxItemStyle<'_> {
213 unsafe { &node_from_id(child_node_id).style }
214 }
215}
216
217impl taffy::LayoutGridContainer for StatelessLayoutTree {
218 type GridContainerStyle<'a>
219 = &'a Style
220 where
221 Self: 'a;
222
223 type GridItemStyle<'a>
224 = &'a Style
225 where
226 Self: 'a;
227
228 fn get_grid_container_style(&self, node_id: NodeId) -> Self::GridContainerStyle<'_> {
229 unsafe { &node_from_id(node_id).style }
230 }
231
232 fn get_grid_child_style(&self, child_node_id: NodeId) -> Self::GridItemStyle<'_> {
233 unsafe { &node_from_id(child_node_id).style }
234 }
235}
236
237impl RoundTree for StatelessLayoutTree {
238 fn get_unrounded_layout(&self, node_id: NodeId) -> &Layout {
239 unsafe { &node_from_id_mut(node_id).unrounded_layout }
240 }
241
242 fn set_final_layout(&mut self, node_id: NodeId, layout: &Layout) {
243 unsafe { node_from_id_mut(node_id).final_layout = *layout }
244 }
245}
246
247impl PrintTree for StatelessLayoutTree {
248 fn get_debug_label(&self, node_id: NodeId) -> &'static str {
249 match unsafe { node_from_id(node_id).kind } {
250 NodeKind::Flexbox => "FLEX",
251 NodeKind::Grid => "GRID",
252 NodeKind::Text => "TEXT",
253 NodeKind::Image => "IMAGE",
254 }
255 }
256
257 fn get_final_layout(&self, node_id: NodeId) -> &Layout {
258 unsafe { &node_from_id(node_id).final_layout }
259 }
260}
261
262fn main() -> Result<(), taffy::TaffyError> {
263 let mut root = Node::new_column(Style::DEFAULT);
264
265 let text_node = Node::new_text(
266 Style::default(),
267 TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal },
268 );
269 root.append_child(text_node);
270
271 let image_node = Node::new_image(Style::default(), ImageContext { width: 400.0, height: 300.0 });
272 root.append_child(image_node);
273
274 // Compute layout and print result
275 root.compute_layout(Size::MAX_CONTENT, true);
276 root.print_tree();
277
278 Ok(())
279}