iced-pancurses 0.1.2

Toy renderer for iced based on pancurses
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

use iced_native::{Color, Column, Container, Element, Length, Radio, Text};
use iced_pancurses::{PancursesRenderer, Sandbox};

struct MyState {
    selected_color: ExampleColor,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExampleColor {
    White,
    Yellow,
    Blue,
    Red,
}

impl ExampleColor {
    pub fn as_iced_color(&self) -> Color {
        match self {
            ExampleColor::White => Color::WHITE,
            ExampleColor::Yellow => Color {
                r: 1.,
                g: 1.,
                b: 0.,
                a: 1.,
            },
            ExampleColor::Blue => Color {
                r: 0.,
                g: 0.,
                b: 1.,
                a: 1.,
            },
            ExampleColor::Red => Color {
                r: 1.,
                g: 0.,
                b: 0.,
                a: 1.,
            },
        }
    }
}

impl Sandbox for MyState {
    type Message = MyMessage;

    fn view(&mut self) -> Element<'_, MyMessage, PancursesRenderer> {
        Container::new(
            Column::new()
                .spacing(1)
                .push(
                    Text::new("Colored text")
                        .width(Length::Shrink)
                        .color(self.selected_color.as_iced_color()),
                )
                .push(
                    Column::new()
                        .push(Radio::new(
                            ExampleColor::White,
                            "White",
                            Some(self.selected_color),
                            |_| MyMessage::SelectColor(ExampleColor::White),
                        ))
                        .push(Radio::new(
                            ExampleColor::Yellow,
                            "Yellow",
                            Some(self.selected_color),
                            |_| MyMessage::SelectColor(ExampleColor::Yellow),
                        ))
                        .push(Radio::new(
                            ExampleColor::Blue,
                            "Blue",
                            Some(self.selected_color),
                            |_| MyMessage::SelectColor(ExampleColor::Blue),
                        ))
                        .push(Radio::new(
                            ExampleColor::Red,
                            "Red",
                            Some(self.selected_color),
                            |_| MyMessage::SelectColor(ExampleColor::Red),
                        )),
                ),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .center_x()
        .center_y()
        .into()
    }

    fn new() -> Self {
        MyState {
            selected_color: ExampleColor::White,
        }
    }

    fn update(&mut self, messages: Vec<MyMessage>) {
        messages.into_iter().for_each(|m| match m {
            MyMessage::SelectColor(c) => self.selected_color = c,
        });
    }
}

#[derive(Debug, Clone, Copy)]
pub enum MyMessage {
    SelectColor(ExampleColor),
}

fn main() {
    MyState::run()
}