cotis-layout 0.1.0-alpha.1

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

use crate::layout_struct::layout_states::LayoutElement;
use crate::layout_struct::layout_tree::{LayoutTree, LayoutTreeCursorBorrow, LayoutTreeIndex};
use crate::layout_struct::{
    RenderCommandClipEnd, RenderCommandClipStart, RenderCommandOutput, RenderCommandOutputElement,
    TextDrawPayload,
};
use cotis::utils::ElementId;
use std::collections::{HashMap, VecDeque};

pub fn calculate_render_commands<Config>(
    tree: &'_ LayoutTree,
    current_tree_index: LayoutTreeIndex,
    open_nodes: &mut VecDeque<LayoutTreeIndex>,
    render_commands: &mut Vec<RenderCommandOutput<Config>>,
    configs: &mut HashMap<ElementId, Config>,
    text_fragments: &HashMap<ElementId, TextDrawPayload>,
) {
    let self_node = LayoutTreeCursorBorrow::new_from_index(tree, &current_tree_index).unwrap();
    let self_node = self_node.get_local();
    let is_layout_root_node = current_tree_index.len() == 1;
    if !is_layout_root_node {
        render_commands.push(self_node.self_element.to_commands(configs, text_fragments));
    }
    if self_node.self_element.config.clip.horizontal || self_node.self_element.config.clip.vertical
    {
        let mut render_commands_inside = Vec::new();
        let mut open_nodes_inside = VecDeque::new();

        render_commands.push(RenderCommandOutput::ClipStart(RenderCommandClipStart {
            bounds: self_node.self_element.info.to_bounding_box(),
            id: self_node.self_element.id,
            z_index: self_node.self_element.config.floating.z_index,
        }));

        for node in self_node.children_elements.iter() {
            let mut index = current_tree_index.clone();
            index.push(node.id);
            open_nodes_inside.push_back(index);
        }
        while let Some(node) = open_nodes_inside.pop_front() {
            calculate_render_commands(
                tree,
                node,
                &mut open_nodes_inside,
                &mut render_commands_inside,
                configs,
                text_fragments,
            );
        }
        sort_commands(
            &mut render_commands_inside,
            self_node.self_element.config.floating.z_index,
        );
        render_commands.append(&mut render_commands_inside);

        render_commands.push(RenderCommandOutput::ClipEnd(RenderCommandClipEnd {
            bounds: self_node.self_element.info.to_bounding_box(),
            id: self_node.self_element.id,
            z_index: self_node.self_element.config.floating.z_index,
        }));
    } else {
        for node in self_node.children_elements.iter() {
            let mut index = current_tree_index.clone();
            index.push(node.id);
            open_nodes.push_back(index);
        }
    }
}

pub(crate) fn sort_commands<Config>(
    render_commands: &mut [RenderCommandOutput<Config>],
    z_index: i32,
) {
    render_commands.sort_by(|a, b| {
        let z_a = match a {
            RenderCommandOutput::Element(a) => a.z_index,
            RenderCommandOutput::ClipStart(a) => a.z_index,
            RenderCommandOutput::ClipEnd(a) => a.z_index,
        };
        let z_b = match b {
            RenderCommandOutput::Element(a) => a.z_index,
            RenderCommandOutput::ClipStart(a) => a.z_index,
            RenderCommandOutput::ClipEnd(a) => a.z_index,
        };

        z_a.cmp(&z_b)
    });
    for command in render_commands.iter_mut() {
        match command {
            RenderCommandOutput::Element(c) => {
                c.z_index = z_index;
            }
            RenderCommandOutput::ClipStart(c) => {
                c.z_index = z_index;
            }
            RenderCommandOutput::ClipEnd(c) => {
                c.z_index = z_index;
            }
        }
    }
}

impl LayoutElement {
    pub fn to_commands<Config>(
        &self,
        configs: &mut HashMap<ElementId, Config>,
        text_fragments: &HashMap<ElementId, TextDrawPayload>,
    ) -> RenderCommandOutput<Config> {
        let text = text_fragments.get(&self.id).cloned();
        RenderCommandOutput::Element(RenderCommandOutputElement {
            bounds: self.info.to_bounding_box(),
            z_index: self.config.floating.z_index,
            text,
            custom: configs
                .remove(&self.id)
                .expect("There should be a config for this element"),
        })
    }
}