lumecs 0.0.1

Experimental GUI backed by Bevy ECS + usual suspects
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

pub use lumecs::prelude::*;

#[derive(Debug, Clone)]
enum Message {
    HeaderClick,
    ItemClick(usize),
    ScrollDown(Point),
    A,
    B,
    ShiftC,
}

struct App {
    header_text: String,
    bottom_text: String,
    scroll_position: Point,
}

fn bottom(bottom_text: &str) -> impl Widget<'_, Message> {
    Container::flex_row().child(Text::new(bottom_text))
}

fn list(app: &App) -> impl Widget<'_, Message> {
    Container::flex_column()
        .flex_grow(1.0)
        .gap(1.0)
        .overflow_y_hidden()
        .scroll_y(app.scroll_position)
        .on_scroll(Message::ScrollDown)
        .children(
            (0..100)
                .map(|i| {
                    Container::flex()
                        .background_color("#00ffff")
                        .on_click(Message::ItemClick(i))
                        .child(Text::new(format!("Item {i}")).color("#111111"))
                })
                .collect(),
        )
}

impl Runner<'_> for App {
    type M = Message;

    fn update(&mut self, message: Message) {
        match message {
            Message::HeaderClick => {
                self.header_text = "Header clicked!".to_string();
            }
            Message::ItemClick(index) => {
                self.bottom_text = format!("Item {index} clicked!");
            }
            Message::ScrollDown(delta) => {
                self.scroll_position += delta;
            }
            Message::A => {
                self.bottom_text = "Key A pressed!".to_string();
            }
            Message::B => {
                self.bottom_text = "Key B pressed!".to_string();
            }
            Message::ShiftC => {
                self.bottom_text = "Shift + C pressed!".to_string();
            }
        }
    }

    fn view(&self) -> impl Widget<'_, Self::M> {
        Root::flex_column()
            .on_key_press(KeyCode::KeyA, Message::A)
            .on_key_press(KeyCode::KeyB, Message::B)
            .on_key_press(SHIFT + KeyCode::KeyC, Message::ShiftC)
            .background_color("#212121")
            .align_items_stretch()
            .child(
                Container::flex()
                    .background_color("#00ff00")
                    .height(60.0)
                    .on_click(Message::HeaderClick)
                    .child(Container::flex().flex_basis(450.0))
                    .child(
                        Container::flex()
                            .flex_grow(1.0)
                            .child(Text::new(self.header_text.clone()).color("#ff0000")),
                    ),
            )
            .child(
                Container::grid()
                    .columns(|t| t.fr(1.0).fr(1.0))
                    .rows(|t| t.fr(1.0).fr(1.0))
                    .child(Text::new("Grid one"))
                    .child(Text::new("Grid two"))
                    .child(Text::new("Grid three"))
                    .child(Text::new("Grid four")),
            )
            .child(
                Container::grid()
                    .background_color("#3d3d3d")
                    .columns(|c| c.fr(1.0).fr(1.0))
                    .gap(5.0)
                    .children(vec![
                        Container::flex()
                            .background_color("#ff0")
                            .child(Text::new("Child one")),
                        Container::flex()
                            .background_color("#f00")
                            .child(Text::new("Child two")),
                    ]),
            )
            .child(Container::flex_row().child(Text::new("Flyover")))
            .child(
                Container::flex_row()
                    .flex_grow(1.0)
                    .gap(5.0)
                    .child(
                        Container::flex_column()
                            .flex_grow(1.0)
                            .child(Text::new("One").font_size(50.0).line_height(60.0)),
                    )
                    .child(
                        Container::flex_column()
                            .background_color("#ff00ff")
                            .flex_grow(1.0)
                            .gap(5.0)
                            .child(Text::new("Two two two two two"))
                            .child(Text::new("Three")),
                    )
                    .child(
                        Container::flex_column()
                            .background_color("#0000ff")
                            .flex_grow(1.0)
                            .gap(5.0)
                            .child(Text::new("Two"))
                            .child(Text::new("Three")),
                    ),
            )
            .child(list(&self))
            .child(bottom(&self.bottom_text))
    }
}

fn main() {
    tracing_subscriber::fmt::init();

    let app = App {
        header_text: "One".to_string(),
        bottom_text: "Bottom".to_string(),
        scroll_position: Point::default(),
    };

    run(app).expect("Failed to run the application");
}