faststep 0.1.0

UIKit-inspired embedded UI framework built on embedded-graphics
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use embedded_graphics::{
    Drawable,
    draw_target::{DrawTarget, DrawTargetExt},
    pixelcolor::Rgb565,
    prelude::{Point, Primitive, Size},
    primitives::{PrimitiveStyleBuilder, Rectangle, RoundedRectangle},
};

use super::layout::{draw_line, layout_lines};
use super::{TextAlignment, TextSpan, TextVerticalAlignment, TextViewStyle};

/// Simple text view that renders one string with one style.
pub struct TextView<'a> {
    /// Outer frame for the text view.
    pub frame: Rectangle,
    /// Plain text content.
    pub text: &'a str,
    /// Style for the whole text string.
    pub style: super::TextRunStyle,
    /// Container-level layout and shell styling.
    pub view_style: TextViewStyle,
}

impl<'a> TextView<'a> {
    /// Creates a plain text view.
    pub const fn new(frame: Rectangle, text: &'a str, style: super::TextRunStyle) -> Self {
        Self {
            frame,
            text,
            style,
            view_style: TextViewStyle::new(),
        }
    }

    /// Replaces the container style.
    pub fn with_view_style(mut self, view_style: TextViewStyle) -> Self {
        self.view_style = view_style;
        self
    }

    /// Draws the text view.
    pub fn draw<D>(&self, display: &mut D)
    where
        D: DrawTarget<Color = Rgb565>,
    {
        let spans = [TextSpan::new(self.text, self.style)];
        draw_text_view(display, self.frame, &spans, &self.view_style);
    }
}

/// Rich text view built from multiple styled spans.
pub struct RichTextView<'a> {
    /// Outer frame for the text view.
    pub frame: Rectangle,
    /// Styled spans rendered in order.
    pub spans: &'a [TextSpan<'a>],
    /// Container-level layout and shell styling.
    pub view_style: TextViewStyle,
}

impl<'a> RichTextView<'a> {
    /// Creates a rich text view.
    pub const fn new(frame: Rectangle, spans: &'a [TextSpan<'a>]) -> Self {
        Self {
            frame,
            spans,
            view_style: TextViewStyle::new(),
        }
    }

    /// Replaces the container style.
    pub fn with_view_style(mut self, view_style: TextViewStyle) -> Self {
        self.view_style = view_style;
        self
    }

    /// Draws the rich text view.
    pub fn draw<D>(&self, display: &mut D)
    where
        D: DrawTarget<Color = Rgb565>,
    {
        draw_text_view(display, self.frame, self.spans, &self.view_style);
    }
}

/// Shared renderer used by [`TextView`] and [`RichTextView`].
pub fn draw_text_view<D>(
    display: &mut D,
    frame: Rectangle,
    spans: &[TextSpan<'_>],
    view_style: &TextViewStyle,
) where
    D: DrawTarget<Color = Rgb565>,
{
    draw_shell(display, frame, view_style);
    let content = view_style.insets.inset_rect(frame);
    if content.size.width == 0 || content.size.height == 0 || spans.is_empty() {
        return;
    }

    let lines = layout_lines(spans, view_style, content.size.width as i32);
    if lines.is_empty() {
        return;
    }

    let spacing = view_style.line_spacing as i32;
    let total_height = lines.iter().map(|line| line.height).sum::<i32>()
        + spacing * (lines.len().saturating_sub(1) as i32);
    let available_height = content.size.height as i32;
    let offset_y = match view_style.vertical_alignment {
        TextVerticalAlignment::Top => 0,
        TextVerticalAlignment::Center => ((available_height - total_height).max(0)) / 2,
        TextVerticalAlignment::Bottom => (available_height - total_height).max(0),
    };

    let mut clipped = display.clipped(&content);
    let mut cursor_y = content.top_left.y + offset_y;
    for line in lines {
        let offset_x = match view_style.alignment {
            TextAlignment::Leading => 0,
            TextAlignment::Center => ((content.size.width as i32 - line.width).max(0)) / 2,
            TextAlignment::Trailing => (content.size.width as i32 - line.width).max(0),
        };
        draw_line(
            &mut clipped,
            spans,
            line,
            Point::new(content.top_left.x + offset_x, cursor_y),
        );
        cursor_y += line.height + spacing;
    }
}

fn draw_shell<D>(display: &mut D, frame: Rectangle, style: &TextViewStyle)
where
    D: DrawTarget<Color = Rgb565>,
{
    if style.background.is_none() && style.border.is_none() {
        return;
    }

    let mut primitive = PrimitiveStyleBuilder::new();
    if let Some(background) = style.background {
        primitive = primitive.fill_color(background);
    }
    if let Some(border) = style.border {
        primitive = primitive
            .stroke_color(border)
            .stroke_width(style.border_width.max(1));
    }

    RoundedRectangle::with_equal_corners(
        frame,
        Size::new(style.corner_radius, style.corner_radius),
    )
    .into_styled(primitive.build())
    .draw(display)
    .ok();
}