summaryrefslogtreecommitdiffstats
path: root/wgpu/src/renderer/checkbox.rs
blob: fd3f08b1231cd3a44d216704a64d824b4e1af585 (plain) (blame)
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
use crate::{Primitive, Renderer};
use iced_native::{
    checkbox, text, text::HorizontalAlignment, text::VerticalAlignment, Align,
    Background, Checkbox, Color, Column, Layout, Length, MouseCursor, Node,
    Point, Rectangle, Row, Text, Widget,
};

const SIZE: f32 = 28.0;

impl checkbox::Renderer for Renderer {
    fn node<Message>(&self, checkbox: &Checkbox<Message>) -> Node {
        Row::<(), Self>::new()
            .spacing(15)
            .align_items(Align::Center)
            .push(
                Column::new()
                    .width(Length::Units(SIZE as u16))
                    .height(Length::Units(SIZE as u16)),
            )
            .push(Text::new(&checkbox.label))
            .node(self)
    }

    fn draw<Message>(
        &mut self,
        checkbox: &Checkbox<Message>,
        layout: Layout<'_>,
        cursor_position: Point,
    ) -> Self::Output {
        let bounds = layout.bounds();
        let mut children = layout.children();

        let checkbox_layout = children.next().unwrap();
        let label_layout = children.next().unwrap();
        let checkbox_bounds = checkbox_layout.bounds();

        let (label, _) = text::Renderer::draw(
            self,
            &Text::new(&checkbox.label),
            label_layout,
        );

        let is_mouse_over = bounds.contains(cursor_position);

        let (checkbox_border, checkbox_box) = (
            Primitive::Quad {
                bounds: checkbox_bounds,
                background: Background::Color(Color {
                    r: 0.6,
                    g: 0.6,
                    b: 0.6,
                    a: 1.0,
                }),
                border_radius: 6,
            },
            Primitive::Quad {
                bounds: Rectangle {
                    x: checkbox_bounds.x + 1.0,
                    y: checkbox_bounds.y + 1.0,
                    width: checkbox_bounds.width - 2.0,
                    height: checkbox_bounds.height - 2.0,
                },
                background: Background::Color(if is_mouse_over {
                    Color {
                        r: 0.90,
                        g: 0.90,
                        b: 0.90,
                        a: 1.0,
                    }
                } else {
                    Color {
                        r: 0.95,
                        g: 0.95,
                        b: 0.95,
                        a: 1.0,
                    }
                }),
                border_radius: 6,
            },
        );

        (
            Primitive::Group {
                primitives: if checkbox.is_checked {
                    // TODO: Draw an actual icon
                    let (check, _) = text::Renderer::draw(
                        self,
                        &Text::new("X")
                            .horizontal_alignment(HorizontalAlignment::Center)
                            .vertical_alignment(VerticalAlignment::Center),
                        checkbox_layout,
                    );

                    vec![checkbox_border, checkbox_box, check, label]
                } else {
                    vec![checkbox_border, checkbox_box, label]
                },
            },
            if is_mouse_over {
                MouseCursor::Pointer
            } else {
                MouseCursor::OutOfBounds
            },
        )
    }
}