Call measure function on leaf nodes even if the node does not have context (#598)
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,
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<'a> Iterator for ChildIter<'a> {
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 fn get_style(&self, node_id: NodeId) -> &Style {
143 &self.node_from_id(node_id).style
144 }
145
146 fn set_unrounded_layout(&mut self, node_id: NodeId, layout: &Layout) {
147 self.node_from_id_mut(node_id).unrounded_layout = *layout;
148 }
149
150 fn get_cache_mut(&mut self, node_id: NodeId) -> &mut Cache {
151 &mut self.node_from_id_mut(node_id).cache
152 }
153
154 fn compute_child_layout(&mut self, node_id: NodeId, inputs: taffy::tree::LayoutInput) -> taffy::tree::LayoutOutput {
155 compute_cached_layout(self, node_id, inputs, |tree, node_id, inputs| {
156 let node = tree.node_from_id_mut(node_id);
157 let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };
158
159 match node.kind {
160 NodeKind::Flexbox => compute_flexbox_layout(tree, node_id, inputs),
161 NodeKind::Grid => compute_grid_layout(tree, node_id, inputs),
162 NodeKind::Text => compute_leaf_layout(inputs, &node.style, |known_dimensions, available_space| {
163 text_measure_function(
164 known_dimensions,
165 available_space,
166 node.text_data.as_ref().unwrap(),
167 &font_metrics,
168 )
169 }),
170 NodeKind::Image => compute_leaf_layout(inputs, &node.style, |known_dimensions, _available_space| {
171 image_measure_function(known_dimensions, node.image_data.as_ref().unwrap())
172 }),
173 }
174 })
175 }
176}
177
178impl taffy::RoundTree for Tree {
179 fn get_unrounded_layout(&self, node_id: NodeId) -> &Layout {
180 &self.node_from_id(node_id).unrounded_layout
181 }
182
183 fn set_final_layout(&mut self, node_id: NodeId, layout: &Layout) {
184 self.node_from_id_mut(node_id).final_layout = *layout;
185 }
186}
187
188impl taffy::PrintTree for Tree {
189 fn get_debug_label(&self, node_id: NodeId) -> &'static str {
190 match self.node_from_id(node_id).kind {
191 NodeKind::Flexbox => "FLEX",
192 NodeKind::Grid => "GRID",
193 NodeKind::Text => "TEXT",
194 NodeKind::Image => "IMAGE",
195 }
196 }
197
198 fn get_final_layout(&self, node_id: NodeId) -> &Layout {
199 &self.node_from_id(node_id).final_layout
200 }
201}
202
203fn main() -> Result<(), taffy::TaffyError> {
204 let mut tree = Tree::new();
205
206 let root = Node::new_column(Style::DEFAULT);
207 let root_id = tree.add_node(root);
208
209 let text_node = Node::new_text(
210 Style::default(),
211 TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal },
212 );
213 let text_node_id = tree.add_node(text_node);
214 tree.append_child(root_id, text_node_id);
215
216 let image_node = Node::new_image(Style::default(), ImageContext { width: 400.0, height: 300.0 });
217 let image_node_id = tree.add_node(image_node);
218 tree.append_child(root_id, image_node_id);
219
220 // Compute layout and print result
221 tree.compute_layout(root_id, Size::MAX_CONTENT, true);
222 tree.print_tree(root_id);
223
224 Ok(())
225}