perf(stack): optimize node creation in Tabs layout

Author: mmstick

src/shell/element/stack/tabs.rs

@@ -374,13 +374,21 @@ where
         state.scrolling = min_size.width > size.width;
         if !state.scrolling {
             // we don't need to scroll
+            nodes.clear();
+
+            // add placeholder nodes for the not rendered scroll-buttons/rules
+            let placeholder_node = Node::new(Size::new(0., 0.));
+            let placeholder_node_with_child =
+                Node::with_children(Size::new(0., 0.), vec![Node::new(Size::new(0., 0.))]);
+            nodes.push(placeholder_node.clone());
+            nodes.push(placeholder_node_with_child.clone());
 
             // can we make every tab equal weight and keep the active large enough?
-            let children = if (size.width / (self.elements.len() as f32 - 5.)).ceil() as i32
+            if (size.width / (self.elements.len() as f32 - 5.)).ceil() as i32
                 >= MIN_ACTIVE_TAB_WIDTH
             {
                 // just use a flex layout
-                cosmic::iced_core::layout::flex::resolve(
+                let node = cosmic::iced_core::layout::flex::resolve(
                     cosmic::iced_core::layout::flex::Axis::Horizontal,
                     renderer,
                     &limits,
@@ -391,16 +399,16 @@ where
                     cosmic::iced::Alignment::Center,
                     &self.elements[2..self.elements.len() - 2],
                     &mut tree.children[2..self.elements.len() - 2],
-                )
-                .children()
-                .to_vec()
+                );
+
+                nodes.extend_from_slice(node.children());
             } else {
                 // otherwise we need a more manual approach
                 let min_width = (size.width - MIN_ACTIVE_TAB_WIDTH as f32 - 4.)
                     / (self.elements.len() as f32 - 6.);
                 let mut offset = 0.;
 
-                let mut nodes = self.elements[2..self.elements.len() - 3]
+                let tab_nodes = self.elements[2..self.elements.len() - 3]
                     .iter()
                     .zip(tree.children[2..].iter_mut())
                     .map(|(tab, tab_tree)| {
@@ -415,76 +423,51 @@ where
                         node = node.move_to(Point::new(offset, 0.));
                         offset += node.bounds().width;
                         node
-                    })
-                    .collect::<Vec<_>>();
+                    });
+
+                nodes.extend(tab_nodes);
                 nodes.push({
                     let node = Node::new(Size::new(4., limits.max().height));
                     node.move_to(Point::new(offset, 0.))
                 });
-                nodes
             };
 
-            // and add placeholder nodes for the not rendered scroll-buttons/rules
-            Node::with_children(
-                size,
-                vec![
-                    Node::new(Size::new(0., 0.)),
-                    Node::with_children(Size::new(0., 0.), vec![Node::new(Size::new(0., 0.))]),
-                ]
-                .into_iter()
-                .chain(children)
-                .chain(vec![
-                    Node::with_children(Size::new(0., 0.), vec![Node::new(Size::new(0., 0.))]),
-                    Node::new(Size::new(0., 0.)),
-                ])
-                .collect::<Vec<_>>(),
-            )
+            // add placeholder nodes for the not rendered scroll-buttons/rules
+            nodes.push(placeholder_node_with_child);
+            nodes.push(placeholder_node);
         } else {
             // we scroll, so use the computed min size, but add scroll buttons.
             let mut offset = 30.;
             for node in &mut nodes {
-                *node = node.clone().move_to(Point::new(offset, 0.));
+                node.move_to_mut(Point::new(offset, 0.));
                 offset += node.bounds().width;
             }
             let last_position = Point::new(size.width - 34., 0.);
             nodes.remove(nodes.len() - 1);
 
-            Node::with_children(
-                size,
-                vec![Node::new(Size::new(4., size.height)), {
-                    let mut node = Node::with_children(
-                        Size::new(16., 16.),
-                        vec![Node::new(Size::new(16., 16.))],
-                    );
-                    node = node.move_to(Point::new(9., (size.height - 16.) / 2.));
-                    node
-                }]
-                .into_iter()
-                .chain(nodes)
-                .chain(vec![
-                    {
-                        let mut node = Node::new(Size::new(4., size.height));
-                        node = node.move_to(last_position);
-                        node
-                    },
-                    {
-                        let mut node = Node::with_children(
-                            Size::new(16., 16.),
-                            vec![Node::new(Size::new(16., 16.))],
-                        );
-                        node =
-                            node.move_to(last_position + Vector::new(9., (size.height - 16.) / 2.));
-                        node
-                    },
-                    {
-                        let mut node = Node::new(Size::new(4., size.height));
-                        node = node.move_to(last_position + Vector::new(30., 0.));
-                        node
-                    },
-                ])
-                .collect(),
-            )
+            // prepend nodes for the prev scroll button.
+            nodes.splice(
+                ..0,
+                vec![
+                    Node::new(Size::new(4., size.height)),
+                    Node::with_children(Size::new(16., 16.), vec![Node::new(Size::new(16., 16.))])
+                        .move_to(Point::new(9., (size.height - 16.) / 2.)),
+                ],
+            );
+
+            // append nodes from the next scroll button.
+            nodes.push(Node::new(Size::new(4., size.height)).move_to(last_position));
+            nodes.push(
+                Node::with_children(Size::new(16., 16.), vec![Node::new(Size::new(16., 16.))])
+                    .move_to(last_position + Vector::new(9., (size.height - 16.) / 2.)),
+            );
+
+            nodes.push(
+                Node::new(Size::new(4., size.height)).move_to(last_position + Vector::new(30., 0.)),
+            );
         }
+
+        Node::with_children(size, nodes)
     }
 
     #[allow(clippy::too_many_lines)]