cotis-layout 0.1.0-alpha

Flexbox-style layout engine for Cotis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

use crate::layout_struct::layout_states::element_info_states::TotalMinSize;
use crate::layout_struct::layout_states::{
    ChildWrapping, LayoutElement, LayoutElementInfo, element_info_states,
};
use crate::layout_struct::layout_tree::LayoutTreeNodeLocal;
use cotis_defaults::element_configs::style::types::LayoutDirection;

/// Vertical min/preferred height from padding + in-flow children (same height rules as
/// [`LayoutTreeNodeLocal::close_element`]), merged with this node's sizing (`calc_start_dim`, clip,
/// declared max on the height axis).
pub(crate) fn merged_vertical_bounds_from_children(
    element: &LayoutElement,
    children: &[&LayoutElement],
) -> (f32, f32) {
    let mut total_min_height =
        element.config.layout.padding.top + element.config.layout.padding.bottom;
    let mut total_pref_height =
        element.config.layout.padding.top + element.config.layout.padding.bottom;

    match element.config.layout.layout_direction {
        LayoutDirection::LeftToRight => {
            let mut max_min_height = 0.0f32;
            let mut max_pref_height = 0.0f32;
            for child in children {
                if child.config.floating.config.is_some() {
                    continue;
                }
                max_min_height = max_min_height.max(
                    child
                        .info
                        .min_height()
                        .expect("child must expose min height during layout"),
                );
                max_pref_height = max_pref_height.max(
                    child
                        .info
                        .temp_height()
                        .expect("child must expose temp height during layout"),
                );
            }
            total_min_height += max_min_height;
            total_pref_height += max_pref_height;
        }
        LayoutDirection::TopToBottom => {
            for child in children {
                if child.config.floating.config.is_some() {
                    continue;
                }
                total_min_height += child
                    .info
                    .min_height()
                    .expect("child must expose min height during layout");
                total_pref_height += child
                    .info
                    .temp_height()
                    .expect("child must expose temp height during layout");
            }
            total_min_height += element.config.layout.child_gap * children.len().max(1) as f32;
        }
    }

    let node_mins = element.calc_start_dim().into_total_min_size();
    let raw_pref_h = node_mins.preferred_size_height.max(total_pref_height);
    let merged_min_h = node_mins
        .min_size_height
        .max(if element.config.clip.vertical {
            0.0
        } else {
            total_min_height
        });
    let merged_pref_h = if element.config.clip.vertical {
        raw_pref_h
    } else {
        raw_pref_h
    };
    (merged_min_h, merged_pref_h)
}

impl LayoutTreeNodeLocal<'_> {
    pub(crate) fn recalculate_min_height_from_children(&mut self) {
        let (merged_min_h, merged_pref_h) =
            merged_vertical_bounds_from_children(self.self_element, &self.children_elements);
        match &self.self_element.info {
            LayoutElementInfo::NotInitialized
            | LayoutElementInfo::TotalSize(_)
            | LayoutElementInfo::TotalSizedAndPosition(_) => {}
            _ => {
                self.self_element.info.set_min_height(merged_min_h);
                self.self_element.info.set_tmp_height(merged_pref_h);
            }
        }
    }

    pub fn open_configuration(&mut self) {
        // Setup z_index
        if self.self_element.config.floating.config.is_none() {
            self.self_element.config.floating.z_index = self
                .parent_element
                .map(|p| p.config.floating.z_index)
                .unwrap_or(0);
        }
    }

    pub fn close_element(&mut self) {
        let mut total_min_size: element_info_states::TotalMinSize = TotalMinSize {
            min_size_width: self.self_element.config.layout.padding.left
                + self.self_element.config.layout.padding.right,
            min_size_height: self.self_element.config.layout.padding.top
                + self.self_element.config.layout.padding.bottom,
            preferred_size_width: self.self_element.config.layout.padding.left
                + self.self_element.config.layout.padding.right,
            preferred_size_height: self.self_element.config.layout.padding.top
                + self.self_element.config.layout.padding.bottom,
        };
        match self.self_element.config.layout.layout_direction {
            LayoutDirection::LeftToRight => {
                let mut max_min_height = 0.0;
                let mut max_pref_height = 0.0;
                let wrap = self.self_element.config.layout.wrapping == ChildWrapping::Text;
                let mut max_min_child_width = 0.0f32;
                for child in &self.children_elements {
                    if let LayoutElementInfo::TotalMinSize(child_min_size) = &child.info {
                        if wrap {
                            max_min_child_width =
                                max_min_child_width.max(child_min_size.min_size_width);
                        } else {
                            total_min_size.min_size_width += child_min_size.min_size_width;
                        }
                        max_min_height = child_min_size.min_size_height.max(max_min_height);
                        total_min_size.preferred_size_width += child_min_size.preferred_size_width;
                        max_pref_height = child_min_size.preferred_size_height.max(max_pref_height);
                    } else {
                        panic!(
                            "How did we get here. Trying to calculate total min size without child total min size"
                        )
                    }
                }
                total_min_size.min_size_height += max_min_height;
                total_min_size.preferred_size_height += max_pref_height;
                if wrap {
                    total_min_size.min_size_width += max_min_child_width;
                    // In text-wrap rows, children are words/spacers and horizontal spacing is
                    // represented by `child_gap`. Preferred width must include that gap budget,
                    // otherwise container preferred width is undersized and words wrap too early.
                    total_min_size.preferred_size_width +=
                        self.self_element.config.layout.child_gap
                            * self.children_elements.len().saturating_sub(1) as f32;
                } else {
                    total_min_size.min_size_width += self.self_element.config.layout.child_gap
                        as f32
                        * self.children_elements.len().max(1) as f32;
                }
            }
            LayoutDirection::TopToBottom => {
                let mut max_min_width = 0.0;
                let mut max_pref_width = 0.0;
                for child in &self.children_elements {
                    if let LayoutElementInfo::TotalMinSize(child_min_size) = &child.info {
                        total_min_size.min_size_height += child_min_size.min_size_height;
                        max_min_width = child_min_size.min_size_width.max(max_min_width);
                        total_min_size.preferred_size_height +=
                            child_min_size.preferred_size_height;
                        max_pref_width = child_min_size.preferred_size_width.max(max_pref_width);
                    } else {
                        panic!(
                            "How did we get here. Trying to calculate total min size without child total min size"
                        )
                    }
                }
                total_min_size.min_size_width += max_min_width;
                total_min_size.preferred_size_width += max_pref_width;
                total_min_size.min_size_height += self.self_element.config.layout.child_gap as f32
                    * self.children_elements.len().max(1) as f32;
            }
        }
        let node_mins = self.self_element.calc_start_dim().into_total_min_size();
        let raw_pref_w = node_mins
            .preferred_size_width
            .max(total_min_size.preferred_size_width);
        let raw_pref_h = node_mins
            .preferred_size_height
            .max(total_min_size.preferred_size_height);
        let max_w = self.self_element.declared_max_axis(true);
        let max_h = self.self_element.declared_max_axis(false);
        let total_min_size = TotalMinSize {
            min_size_width: node_mins.min_size_width.max(
                if self.self_element.config.clip.horizontal {
                    0.0
                } else {
                    total_min_size.min_size_width.min(max_w)
                },
            ),
            min_size_height: node_mins.min_size_height.max(
                if self.self_element.config.clip.vertical {
                    0.0
                } else {
                    total_min_size.min_size_height.min(max_h)
                },
            ),
            // Clipping allows overflow in child layout, but the element's own box must still
            // honor its declared sizing bounds (e.g. Fixed / Fit / Grow max).
            preferred_size_width: raw_pref_w.min(max_w),
            preferred_size_height: raw_pref_h.min(max_h),
        };
        self.self_element.info = LayoutElementInfo::TotalMinSize(total_min_size);
    }
}