Method propagate_sizes_up_tree

src/engine.rs:3517–3637

(&mut self)

    }

    fn propagate_sizes_up_tree(&mut self) {
        let mut dfs_buffer: Vec<i32> = Vec::new();
        let mut visited: Vec<bool> = Vec::new();

        for i in 0..self.layout_element_tree_roots.len() {
            let root = self.layout_element_tree_roots[i];
            dfs_buffer.push(root.layout_element_index);
            visited.push(false);
        }

        while !dfs_buffer.is_empty() {
            let buf_idx = dfs_buffer.len() - 1;
            let current_elem_idx = dfs_buffer[buf_idx] as usize;

            if !visited[buf_idx] {
                visited[buf_idx] = true;
                let is_text =
                    self.element_has_config(current_elem_idx, ElementConfigType::Text);
                let children_length = self.layout_elements[current_elem_idx].children_length;
                if is_text || children_length == 0 {
                    dfs_buffer.pop();
                    visited.pop();
                    continue;
                }
                let children_start = self.layout_elements[current_elem_idx].children_start;
                for j in 0..children_length as usize {
                    let child_idx = self.layout_element_children[children_start + j];
                    dfs_buffer.push(child_idx);
                    visited.push(false);
                }
                continue;
            }

            dfs_buffer.pop();
            visited.pop();

            let layout_idx = self.layout_elements[current_elem_idx].layout_config_index;
            let layout_config = self.layout_configs[layout_idx];
            let children_start = self.layout_elements[current_elem_idx].children_start;
            let children_length = self.layout_elements[current_elem_idx].children_length;

            if layout_config.layout_direction == LayoutDirection::LeftToRight {
                if layout_config.wrap {
                    let lines = self.compute_wrapped_lines(current_elem_idx, true);
                    let mut content_height =
                        layout_config.padding.top as f32 + layout_config.padding.bottom as f32;
                    if !lines.is_empty() {
                        content_height +=
                            lines.iter().map(|line| line.cross_size).sum::<f32>();
                        content_height +=
                            lines.len().saturating_sub(1) as f32 * layout_config.wrap_gap as f32;
                    }
                    self.layout_elements[current_elem_idx].dimensions.height = f32::min(
                        f32::max(content_height, layout_config.sizing.height.min_max.min),
                        layout_config.sizing.height.min_max.max,
                    );
                } else {
                    for j in 0..children_length as usize {