matrix-gui 0.3.0

embedded-graphics based GUI framework, use region-based freeform layout.
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
121
122
123
124
125
126
127
128
129
130
131
132

//! Button widget for user interaction.
//!
//! This module provides a clickable button widget that responds to
//! touch/click events and optionally focus events. The button displays
//! a label and can have customizable border and corner radius.

use crate::prelude::*;

/// Button widget for user interaction.
///
/// This widget displays a clickable button with a text label. It responds
/// to touch/click events and optionally focus events (when the `focus`
/// feature is enabled). The button can have customizable border width
/// and corner radius.
///
/// # Type Parameters
///
/// * `'a` - The lifetime of the label string reference
/// * `ID` - The widget ID type implementing [`WidgetId`]
pub struct Button<'a, ID> {
    /// The region defining the button's position and size.
    region: &'a Region<ID>,
    /// The text label to display on the button.
    label: &'a str,
    /// Optional border (width, corner_radius).
    border: Option<(u8, u8)>,
}

impl<'a, ID: WidgetId> Button<'a, ID> {
    pub const fn new(region: &'a Region<ID>, label: &'a str) -> Button<'a, ID> {
        Button {
            region,
            label,
            border: None,
        }
    }

    pub const fn with_border(mut self, border: u8, radius: u8) -> Self {
        self.border = Some((border, radius));
        self
    }
}

impl<DRAW: DrawTarget<Color = COL>, ID: WidgetId, COL: PixelColor> Widget<DRAW, COL>
    for Button<'_, ID>
{
    fn draw(&mut self, ui: &mut Ui<DRAW, COL>) -> GuiResult<Response> {
        #[allow(unused_mut)]
        let mut interaction = ui.check_interact(self.region);
        let widget_id = self.region.id();
        #[cfg(feature = "focus")]
        let focused = ui.check_focused(widget_id);

        let prevstate = ui.get_widget_state(widget_id)?.status();
        let next_state;
        match interaction {
            Interaction::None => {
                #[cfg(feature = "focus")]
                {
                    use crate::focus::Focused;

                    match focused {
                        Focused::No => {
                            next_state = RenderStatus::Rendered;
                        }
                        Focused::Yes => {
                            next_state = RenderStatus::Focused;
                            interaction = focused.into();
                        }
                        Focused::Trigger => {
                            interaction = focused.into();
                            next_state = RenderStatus::Triggered;
                        }
                    }
                }

                #[cfg(not(feature = "focus"))]
                {
                    next_state = RenderStatus::Rendered;
                }
            }
            Interaction::Pressed(_) | Interaction::Drag(_) => {
                next_state = RenderStatus::Pressed;
            }
            Interaction::Release(pos) | Interaction::Clicked(pos) => {
                next_state = RenderStatus::Released;
                interaction = Interaction::Clicked(pos);
            }
        };

        if next_state == prevstate {
            return Ok(interaction.into());
        }
        ui.get_widget_state(widget_id)?.set_status(next_state);

        let area = self.region.rectangle();
        let font = ui.style().default_font;
        let mut text = matrix_utils::make_text(self.label, font, ui.style().text_color);

        let (border_width, corner_radius) = self
            .border
            .unwrap_or((ui.style().border_width, ui.style().corner_radius));
        let border_width = border_width as u32;
        let corner_radius = corner_radius as u32;
        let rounded_rect = matrix_utils::make_rounded_rect(&area, corner_radius);

        ui.clear_area(&area)?;

        let rect_style = match interaction {
            Interaction::None => PrimitiveStyleBuilder::new()
                .stroke_color(ui.style().border_color)
                .stroke_width(border_width)
                .fill_color(ui.style().background_color)
                .build(),
            _ => {
                text.character_style.text_color = ui.style().background_color;
                PrimitiveStyleBuilder::new()
                    .stroke_color(ui.style().background_color)
                    .stroke_width(border_width)
                    .fill_color(ui.style().border_color)
                    .build()
            }
        };

        ui.draw(&rounded_rect.into_styled(rect_style)).ok();

        matrix_utils::text_align_translate(&mut text, &area, HorizontalAlign::Center);
        ui.draw(&text).ok();

        Ok(interaction.into())
    }
}