Fix clippy lints (2024-10-10) (#720)
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 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> = &'a Style where
143 Self: 'a;
144
145 type CacheMut<'b> = &'b mut Cache where Self: 'b;
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 get_cache_mut(&mut self, node_id: NodeId) -> &mut Cache {
156 &mut self.node_from_id_mut(node_id).cache
157 }
158
159 fn compute_child_layout(&mut self, node_id: NodeId, inputs: taffy::tree::LayoutInput) -> taffy::tree::LayoutOutput {
160 compute_cached_layout(self, node_id, inputs, |tree, node_id, inputs| {
161 let node = tree.node_from_id_mut(node_id);
162 let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };
163
164 match node.kind {
165 NodeKind::Flexbox => compute_flexbox_layout(tree, node_id, inputs),
166 NodeKind::Grid => compute_grid_layout(tree, node_id, inputs),
167 NodeKind::Text => compute_leaf_layout(inputs, &node.style, |known_dimensions, available_space| {
168 text_measure_function(
169 known_dimensions,
170 available_space,
171 node.text_data.as_ref().unwrap(),
172 &font_metrics,
173 )
174 }),
175 NodeKind::Image => compute_leaf_layout(inputs, &node.style, |known_dimensions, _available_space| {
176 image_measure_function(known_dimensions, node.image_data.as_ref().unwrap())
177 }),
178 }
179 })
180 }
181}
182
183impl taffy::LayoutFlexboxContainer for Tree {
184 type FlexboxContainerStyle<'a> = &'a Style where
185 Self: 'a;
186
187 type FlexboxItemStyle<'a> = &'a Style where
188 Self: 'a;
189
190 fn get_flexbox_container_style(&self, node_id: NodeId) -> Self::FlexboxContainerStyle<'_> {
191 &self.node_from_id(node_id).style
192 }
193
194 fn get_flexbox_child_style(&self, child_node_id: NodeId) -> Self::FlexboxItemStyle<'_> {
195 &self.node_from_id(child_node_id).style
196 }
197}
198
199impl taffy::LayoutGridContainer for Tree {
200 type GridContainerStyle<'a> = &'a Style where
201 Self: 'a;
202
203 type GridItemStyle<'a> = &'a Style where
204 Self: 'a;
205
206 fn get_grid_container_style(&self, node_id: NodeId) -> Self::GridContainerStyle<'_> {
207 &self.node_from_id(node_id).style
208 }
209
210 fn get_grid_child_style(&self, child_node_id: NodeId) -> Self::GridItemStyle<'_> {
211 &self.node_from_id(child_node_id).style
212 }
213}
214
215impl taffy::RoundTree for Tree {
216 fn get_unrounded_layout(&self, node_id: NodeId) -> &Layout {
217 &self.node_from_id(node_id).unrounded_layout
218 }
219
220 fn set_final_layout(&mut self, node_id: NodeId, layout: &Layout) {
221 self.node_from_id_mut(node_id).final_layout = *layout;
222 }
223}
224
225impl taffy::PrintTree for Tree {
226 fn get_debug_label(&self, node_id: NodeId) -> &'static str {
227 match self.node_from_id(node_id).kind {
228 NodeKind::Flexbox => "FLEX",
229 NodeKind::Grid => "GRID",
230 NodeKind::Text => "TEXT",
231 NodeKind::Image => "IMAGE",
232 }
233 }
234
235 fn get_final_layout(&self, node_id: NodeId) -> &Layout {
236 &self.node_from_id(node_id).final_layout
237 }
238}
239
240fn main() -> Result<(), taffy::TaffyError> {
241 let mut tree = Tree::new();
242
243 let root = Node::new_column(Style::DEFAULT);
244 let root_id = tree.add_node(root);
245
246 let text_node = Node::new_text(
247 Style::default(),
248 TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal },
249 );
250 let text_node_id = tree.add_node(text_node);
251 tree.append_child(root_id, text_node_id);
252
253 let image_node = Node::new_image(Style::default(), ImageContext { width: 400.0, height: 300.0 });
254 let image_node_id = tree.add_node(image_node);
255 tree.append_child(root_id, image_node_id);
256
257 // Compute layout and print result
258 tree.compute_layout(root_id, Size::MAX_CONTENT, true);
259 tree.print_tree(root_id);
260
261 Ok(())
262}