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