oters_gui 0.1.2

Graphical library definitions for the oters programming language
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

use oters_lang::export::export_oters;

use super::{Alignment, Frame, UIInstance, UIType, FRAMES};

const PADDING: u32 = 10;
#[export_oters]
pub fn create_vgroup(frame_id: i64, size: (i64, i64), align: Alignment) -> i64 {
    let frame = &mut FRAMES.lock().unwrap()[frame_id as usize];
    let id = frame.elems.len();
    frame.elems.push(UIInstance {
        ty: UIType::VGroup(align),
        pos: (0, 0),
        size: (size.0 as u32, size.1 as u32),
        visible: false,
    });
    id as i64
}

#[export_oters]
pub fn draw_vgroup(frame_id: i64, grp_id: i64, elems: Vec<i64>) {
    let frame = &mut FRAMES.lock().unwrap()[frame_id as usize];
    let grp = &frame.elems[grp_id as usize].clone();
    match grp {
        UIInstance {
            ty: UIType::VGroup(align),
            pos: g_pos,
            size: g_size,
            visible,
        } => {
            if !visible {
                return oters_lang::export::Value::Unit;
            }
            let g_pos = (g_pos.0 + frame.pos.0, g_pos.1 + frame.pos.1);
            match align {
                Alignment::Left => draw_left(g_pos, *g_size, frame, elems),
                Alignment::Right => draw_right(g_pos, *g_size, frame, elems),
                _ => draw_left(g_pos, *g_size, frame, elems),
            }
        }
        _ => panic!("Expected a vgroup"),
    }
}

fn draw_left(g_pos: (u32, u32), g_size: (u32, u32), frame: &mut Frame, elems: Vec<i64>) {
    let max_x = g_pos.0 + g_size.0 - PADDING;
    let max_y = g_pos.1 + g_size.1 - PADDING;

    let mut x = g_pos.0 + PADDING;
    let mut y = g_pos.1 + PADDING;
    let mut dy = 0;

    for e_id in elems {
        let elem = &mut frame.elems[e_id as usize];
        match elem.ty {
            UIType::Separator => {
                elem.size = (g_size.0 - 2 * PADDING, 2);
            }
            _ => (),
        }
        if !(x + elem.size.0 > max_x) {
            if !(y + elem.size.1 > max_y) {
                elem.pos = (x, y);
                elem.visible = true;
                x += elem.size.0 + PADDING;
                dy = dy.max(elem.size.1 + PADDING);
            } else {
                break;
            }
        } else {
            if !(g_pos.0 + PADDING + elem.size.0 > max_x) {
                x = g_pos.0 + PADDING;
                y += dy;
                dy = 0;
                elem.pos = (x, y);
                elem.visible = true;
                x += elem.size.0 + PADDING;
                dy = dy.max(elem.size.1 + PADDING);
            }
        }
    }
}

fn draw_right(g_pos: (u32, u32), g_size: (u32, u32), frame: &mut Frame, elems: Vec<i64>) {
    let min_x = g_pos.0 + PADDING;
    let max_y = g_pos.1 + g_size.1 - PADDING;

    let mut x = g_pos.0 + g_size.0 - PADDING;
    let mut y = g_pos.1 + PADDING;
    let mut dy = 0;

    for e_id in elems {
        let elem = &mut frame.elems[e_id as usize];
        match elem.ty {
            UIType::Separator => {
                elem.size = (g_size.0 - 2 * PADDING, 2);
            }
            _ => (),
        }
        if x > elem.size.0 && !(x - elem.size.0 < min_x) {
            if !(y + elem.size.1 > max_y) {
                elem.pos = (x - elem.size.0, y);
                elem.visible = true;
                x -= elem.size.0 + PADDING;
                dy = dy.max(elem.size.1 + PADDING);
            } else {
                break;
            }
        } else {
            if !(g_pos.0 + g_size.0 - PADDING - elem.size.0 < min_x) {
                x = g_pos.0 + g_size.0 - PADDING;
                y += dy;
                dy = 0;
                elem.pos = (x - elem.size.0, y);
                elem.visible = true;
                x -= elem.size.0 - PADDING;
                dy = dy.max(elem.size.1 + PADDING);
            }
        }
    }
}