Struct TextViewStyle 

pub struct TextViewStyle {
    pub alignment: TextAlignment,
    pub vertical_alignment: TextVerticalAlignment,
    pub wrap: TextWrap,
    pub line_spacing: u32,
    pub insets: EdgeInsets,
    pub background: Option<Rgb565>,
    pub border: Option<Rgb565>,
    pub border_width: u32,
    pub corner_radius: u32,
}

Shared container style for crate::TextView and crate::RichTextView.

Fields

alignment: TextAlignment

Horizontal alignment for rendered lines.

vertical_alignment: TextVerticalAlignment

Vertical alignment for the rendered block.

wrap: TextWrap

Wrapping behavior.

line_spacing: u32

Extra spacing inserted between lines.

insets: EdgeInsets

Content padding.

background: Option<Rgb565>

Optional background fill for the shell.

border: Option<Rgb565>

Optional border color for the shell.

border_width: u32

Border width in pixels.

corner_radius: u32

Corner radius for the shell.

Implementations

impl TextViewStyle

pub const fn new() -> Self

Creates the default text view style.

Examples found in repository

examples/text_and_image.rs (line 44)

fn main() {
    let mut canvas = support::NullCanvas::new(Size::new(320, 240));

    let image_data = [
        0xF8, 0x00, 0x07, 0xE0, //
        0x07, 0xE0, 0xF8, 0x00, //
    ];
    let image: ImageRawBE<Rgb565> = ImageRaw::new(&image_data, 2);

    ImageView::new(
        Rectangle::new(Point::new(16, 16), Size::new(72, 72)),
        &image,
    )
    .with_style(
        ImageViewStyle::new()
            .with_alignment(ImageAlignment::Center)
            .with_insets(EdgeInsets::all(8))
            .with_background(Rgb565::new(28, 58, 28))
            .with_border(Rgb565::new(20, 44, 20), 2)
            .with_corner_radius(12),
    )
    .draw(&mut canvas);

    TextView::new(
        Rectangle::new(Point::new(104, 18), Size::new(192, 28)),
        "Faststep",
        TextRunStyle::title(Rgb565::BLACK),
    )
    .with_view_style(
        TextViewStyle::new()
            .with_alignment(TextAlignment::Leading)
            .with_vertical_alignment(TextVerticalAlignment::Center),
    )
    .draw(&mut canvas);

    let spans = [
        TextSpan::new("UIKit-like ", TextRunStyle::body(Rgb565::BLACK)),
        TextSpan::new("embedded UI", TextRunStyle::body_strong(Rgb565::BLUE)),
        TextSpan::new(
            "\nfor devices and simulators",
            TextRunStyle::caption(Rgb565::GREEN),
        ),
    ];
    RichTextView::new(
        Rectangle::new(Point::new(104, 58), Size::new(192, 72)),
        &spans,
    )
    .with_view_style(
        TextViewStyle::new()
            .with_wrap(TextWrap::Multiline)
            .with_insets(EdgeInsets::all(4)),
    )
    .draw(&mut canvas);
}

src/text_view/types.rs (line 218)

    fn default() -> Self {
        Self::new()
    }

src/text_view/widget.rs (line 31)

    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(),
        }
    }

pub fn with_alignment(self, alignment: TextAlignment) -> Self

Sets horizontal alignment.

Examples found in repository

examples/text_and_image.rs (line 45)

fn main() {
    let mut canvas = support::NullCanvas::new(Size::new(320, 240));

    let image_data = [
        0xF8, 0x00, 0x07, 0xE0, //
        0x07, 0xE0, 0xF8, 0x00, //
    ];
    let image: ImageRawBE<Rgb565> = ImageRaw::new(&image_data, 2);

    ImageView::new(
        Rectangle::new(Point::new(16, 16), Size::new(72, 72)),
        &image,
    )
    .with_style(
        ImageViewStyle::new()
            .with_alignment(ImageAlignment::Center)
            .with_insets(EdgeInsets::all(8))
            .with_background(Rgb565::new(28, 58, 28))
            .with_border(Rgb565::new(20, 44, 20), 2)
            .with_corner_radius(12),
    )
    .draw(&mut canvas);

    TextView::new(
        Rectangle::new(Point::new(104, 18), Size::new(192, 28)),
        "Faststep",
        TextRunStyle::title(Rgb565::BLACK),
    )
    .with_view_style(
        TextViewStyle::new()
            .with_alignment(TextAlignment::Leading)
            .with_vertical_alignment(TextVerticalAlignment::Center),
    )
    .draw(&mut canvas);

    let spans = [
        TextSpan::new("UIKit-like ", TextRunStyle::body(Rgb565::BLACK)),
        TextSpan::new("embedded UI", TextRunStyle::body_strong(Rgb565::BLUE)),
        TextSpan::new(
            "\nfor devices and simulators",
            TextRunStyle::caption(Rgb565::GREEN),
        ),
    ];
    RichTextView::new(
        Rectangle::new(Point::new(104, 58), Size::new(192, 72)),
        &spans,
    )
    .with_view_style(
        TextViewStyle::new()
            .with_wrap(TextWrap::Multiline)
            .with_insets(EdgeInsets::all(4)),
    )
    .draw(&mut canvas);
}

pub fn with_vertical_alignment(self, alignment: TextVerticalAlignment) -> Self

Sets vertical alignment.

Examples found in repository

examples/text_and_image.rs (line 46)

fn main() {
    let mut canvas = support::NullCanvas::new(Size::new(320, 240));

    let image_data = [
        0xF8, 0x00, 0x07, 0xE0, //
        0x07, 0xE0, 0xF8, 0x00, //
    ];
    let image: ImageRawBE<Rgb565> = ImageRaw::new(&image_data, 2);

    ImageView::new(
        Rectangle::new(Point::new(16, 16), Size::new(72, 72)),
        &image,
    )
    .with_style(
        ImageViewStyle::new()
            .with_alignment(ImageAlignment::Center)
            .with_insets(EdgeInsets::all(8))
            .with_background(Rgb565::new(28, 58, 28))
            .with_border(Rgb565::new(20, 44, 20), 2)
            .with_corner_radius(12),
    )
    .draw(&mut canvas);

    TextView::new(
        Rectangle::new(Point::new(104, 18), Size::new(192, 28)),
        "Faststep",
        TextRunStyle::title(Rgb565::BLACK),
    )
    .with_view_style(
        TextViewStyle::new()
            .with_alignment(TextAlignment::Leading)
            .with_vertical_alignment(TextVerticalAlignment::Center),
    )
    .draw(&mut canvas);

    let spans = [
        TextSpan::new("UIKit-like ", TextRunStyle::body(Rgb565::BLACK)),
        TextSpan::new("embedded UI", TextRunStyle::body_strong(Rgb565::BLUE)),
        TextSpan::new(
            "\nfor devices and simulators",
            TextRunStyle::caption(Rgb565::GREEN),
        ),
    ];
    RichTextView::new(
        Rectangle::new(Point::new(104, 58), Size::new(192, 72)),
        &spans,
    )
    .with_view_style(
        TextViewStyle::new()
            .with_wrap(TextWrap::Multiline)
            .with_insets(EdgeInsets::all(4)),
    )
    .draw(&mut canvas);
}

pub fn with_wrap(self, wrap: TextWrap) -> Self

Sets wrapping behavior.

Examples found in repository

examples/text_and_image.rs (line 64)

fn main() {
    let mut canvas = support::NullCanvas::new(Size::new(320, 240));

    let image_data = [
        0xF8, 0x00, 0x07, 0xE0, //
        0x07, 0xE0, 0xF8, 0x00, //
    ];
    let image: ImageRawBE<Rgb565> = ImageRaw::new(&image_data, 2);

    ImageView::new(
        Rectangle::new(Point::new(16, 16), Size::new(72, 72)),
        &image,
    )
    .with_style(
        ImageViewStyle::new()
            .with_alignment(ImageAlignment::Center)
            .with_insets(EdgeInsets::all(8))
            .with_background(Rgb565::new(28, 58, 28))
            .with_border(Rgb565::new(20, 44, 20), 2)
            .with_corner_radius(12),
    )
    .draw(&mut canvas);

    TextView::new(
        Rectangle::new(Point::new(104, 18), Size::new(192, 28)),
        "Faststep",
        TextRunStyle::title(Rgb565::BLACK),
    )
    .with_view_style(
        TextViewStyle::new()
            .with_alignment(TextAlignment::Leading)
            .with_vertical_alignment(TextVerticalAlignment::Center),
    )
    .draw(&mut canvas);

    let spans = [
        TextSpan::new("UIKit-like ", TextRunStyle::body(Rgb565::BLACK)),
        TextSpan::new("embedded UI", TextRunStyle::body_strong(Rgb565::BLUE)),
        TextSpan::new(
            "\nfor devices and simulators",
            TextRunStyle::caption(Rgb565::GREEN),
        ),
    ];
    RichTextView::new(
        Rectangle::new(Point::new(104, 58), Size::new(192, 72)),
        &spans,
    )
    .with_view_style(
        TextViewStyle::new()
            .with_wrap(TextWrap::Multiline)
            .with_insets(EdgeInsets::all(4)),
    )
    .draw(&mut canvas);
}

pub fn with_line_spacing(self, line_spacing: u32) -> Self

Sets extra line spacing.

pub fn with_insets(self, insets: EdgeInsets) -> Self

Sets content padding.

Examples found in repository

examples/text_and_image.rs (line 65)

fn main() {
    let mut canvas = support::NullCanvas::new(Size::new(320, 240));

    let image_data = [
        0xF8, 0x00, 0x07, 0xE0, //
        0x07, 0xE0, 0xF8, 0x00, //
    ];
    let image: ImageRawBE<Rgb565> = ImageRaw::new(&image_data, 2);

    ImageView::new(
        Rectangle::new(Point::new(16, 16), Size::new(72, 72)),
        &image,
    )
    .with_style(
        ImageViewStyle::new()
            .with_alignment(ImageAlignment::Center)
            .with_insets(EdgeInsets::all(8))
            .with_background(Rgb565::new(28, 58, 28))
            .with_border(Rgb565::new(20, 44, 20), 2)
            .with_corner_radius(12),
    )
    .draw(&mut canvas);

    TextView::new(
        Rectangle::new(Point::new(104, 18), Size::new(192, 28)),
        "Faststep",
        TextRunStyle::title(Rgb565::BLACK),
    )
    .with_view_style(
        TextViewStyle::new()
            .with_alignment(TextAlignment::Leading)
            .with_vertical_alignment(TextVerticalAlignment::Center),
    )
    .draw(&mut canvas);

    let spans = [
        TextSpan::new("UIKit-like ", TextRunStyle::body(Rgb565::BLACK)),
        TextSpan::new("embedded UI", TextRunStyle::body_strong(Rgb565::BLUE)),
        TextSpan::new(
            "\nfor devices and simulators",
            TextRunStyle::caption(Rgb565::GREEN),
        ),
    ];
    RichTextView::new(
        Rectangle::new(Point::new(104, 58), Size::new(192, 72)),
        &spans,
    )
    .with_view_style(
        TextViewStyle::new()
            .with_wrap(TextWrap::Multiline)
            .with_insets(EdgeInsets::all(4)),
    )
    .draw(&mut canvas);
}

pub fn with_background(self, background: Rgb565) -> Self

Sets the shell background color.

pub fn with_border(self, border: Rgb565, border_width: u32) -> Self

Sets shell border color and width.

pub fn with_corner_radius(self, corner_radius: u32) -> Self

Sets the shell corner radius.

Trait Implementations

impl Clone for TextViewStyle

fn clone(&self) -> TextViewStyle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TextViewStyle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TextViewStyle

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for TextViewStyle

fn eq(&self, other: &TextViewStyle) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for TextViewStyle

impl Eq for TextViewStyle

impl StructuralPartialEq for TextViewStyle