Struct ratatui::text::Line

source ·

pub struct Line<'a> {
    pub spans: Vec<Span<'a>>,
    pub alignment: Option<Alignment>,
}

Fields§

§spans: Vec<Span<'a>>§alignment: Option<Alignment>

Implementations§

source §

impl<'a> Line<'a>

source

pub fn raw<T>(content: T) -> Line<'a>
where T: Into<Cow<'a, str>>,

Create a line with the default style.

Examples

Line::raw("test content");
Line::raw(String::from("test content"));

source

pub fn styled<T>(content: T, style: Style) -> Line<'a>
where T: Into<Cow<'a, str>>,

Create a line with a style.

Examples

let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
Line::styled("My text", style);
Line::styled(String::from("My text"), style);

source

pub fn width(&self) -> usize

Returns the width of the underlying string.

Examples

let line = Line::from(vec![
    Span::styled("My", Style::default().fg(Color::Yellow)),
    Span::raw(" text"),
]);
assert_eq!(7, line.width());

Examples found in repository ?

examples/custom_widget.rs (line 103)

    fn render(self, area: Rect, buf: &mut Buffer) {
        let (background, text, shadow, highlight) = self.colors();
        buf.set_style(area, Style::new().bg(background).fg(text));

        // render top line if there's enough space
        if area.height > 2 {
            buf.set_string(
                area.x,
                area.y,
                "▔".repeat(area.width as usize),
                Style::new().fg(highlight).bg(background),
            );
        }
        // render bottom line if there's enough space
        if area.height > 1 {
            buf.set_string(
                area.x,
                area.y + area.height - 1,
                "▁".repeat(area.width as usize),
                Style::new().fg(shadow).bg(background),
            );
        }
        // render label centered
        buf.set_line(
            area.x + (area.width.saturating_sub(self.label.width() as u16)) / 2,
            area.y + (area.height.saturating_sub(1)) / 2,
            &self.label,
            area.width,
        );
    }

source

pub fn styled_graphemes( &'a self, base_style: Style ) -> impl Iterator<Item = StyledGrapheme<'a>>

Returns an iterator over the graphemes held by this line.

base_style is the Style that will be patched with each grapheme Style to get the resulting Style.

Examples

use std::iter::Iterator;
use ratatui::{prelude::*, text::StyledGrapheme};

let line = Line::styled("Text", Style::default().fg(Color::Yellow));
let style = Style::default().fg(Color::Green).bg(Color::Black);
assert_eq!(
    line.styled_graphemes(style).collect::<Vec<StyledGrapheme>>(),
    vec![
        StyledGrapheme::new("T", Style::default().fg(Color::Yellow).bg(Color::Black)),
        StyledGrapheme::new("e", Style::default().fg(Color::Yellow).bg(Color::Black)),
        StyledGrapheme::new("x", Style::default().fg(Color::Yellow).bg(Color::Black)),
        StyledGrapheme::new("t", Style::default().fg(Color::Yellow).bg(Color::Black)),
    ]
);

source

pub fn patch_style(&mut self, style: Style)

Patches the style of each Span in an existing Line, adding modifiers from the given style.

Examples

let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
let mut raw_line = Line::from(vec![
    Span::raw("My"),
    Span::raw(" text"),
]);
let mut styled_line = Line::from(vec![
    Span::styled("My", style),
    Span::styled(" text", style),
]);

assert_ne!(raw_line, styled_line);

raw_line.patch_style(style);
assert_eq!(raw_line, styled_line);

source

pub fn reset_style(&mut self)

Resets the style of each Span in the Line. Equivalent to calling patch_style(Style::reset()).

Examples

let mut line = Line::from(vec![
    Span::styled("My", Style::default().fg(Color::Yellow)),
    Span::styled(" text", Style::default().add_modifier(Modifier::BOLD)),
]);

line.reset_style();
assert_eq!(Style::reset(), line.spans[0].style);
assert_eq!(Style::reset(), line.spans[1].style);

source

pub fn alignment(self, alignment: Alignment) -> Self

Sets the target alignment for this line of text. Defaults to: None, meaning the alignment is determined by the rendering widget.

Examples

let mut line = Line::from("Hi, what's up?");
assert_eq!(None, line.alignment);
assert_eq!(Some(Alignment::Right), line.alignment(Alignment::Right).alignment)

Examples found in repository ?

examples/barchart.rs (line 195)

fn create_groups<'a>(app: &'a App, combine_values_and_labels: bool) -> Vec<BarGroup<'a>> {
    app.months
        .iter()
        .enumerate()
        .map(|(i, &month)| {
            let bars: Vec<Bar> = app
                .companies
                .iter()
                .map(|c| {
                    let mut bar = Bar::default()
                        .value(c.revenue[i])
                        .style(c.bar_style)
                        .value_style(
                            Style::default()
                                .bg(c.bar_style.fg.unwrap())
                                .fg(Color::Black),
                        );

                    if combine_values_and_labels {
                        bar = bar.text_value(format!(
                            "{} ({:.1} M)",
                            c.label,
                            (c.revenue[i] as f64) / 1000.
                        ));
                    } else {
                        bar = bar
                            .text_value(format!("{:.1}", (c.revenue[i] as f64) / 1000.))
                            .label(c.label.into());
                    }
                    bar
                })
                .collect();
            BarGroup::default()
                .label(Line::from(month).alignment(Alignment::Center))
                .bars(&bars)
        })
        .collect()
}

More examples

Hide additional examples

examples/layout.rs (line 64)

fn ui(frame: &mut Frame) {
    let main_layout = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Length(4),  // text
            Length(50), // examples
            Min(0),     // fills remaining space
        ])
        .split(frame.size());

    // title
    frame.render_widget(
        Paragraph::new(vec![
            Line::from("Horizontal Layout Example. Press q to quit".dark_gray())
                .alignment(Alignment::Center),
            Line::from("Each line has 2 constraints, plus Min(0) to fill the remaining space."),
            Line::from("E.g. the second line of the Len/Min box is [Length(2), Min(2), Min(0)]"),
            Line::from("Note: constraint labels that don't fit are truncated"),
        ]),
        main_layout[0],
    );

    let example_rows = Layout::default()
        .direction(Direction::Vertical)
        .constraints([
            Length(9),
            Length(9),
            Length(9),
            Length(9),
            Length(9),
            Min(0), // fills remaining space
        ])
        .split(main_layout[1]);
    let example_areas = example_rows
        .iter()
        .flat_map(|area| {
            Layout::default()
                .direction(Direction::Horizontal)
                .constraints([
                    Length(14),
                    Length(14),
                    Length(14),
                    Length(14),
                    Length(14),
                    Min(0), // fills remaining space
                ])
                .split(*area)
                .iter()
                .copied()
                .take(5) // ignore Min(0)
                .collect_vec()
        })
        .collect_vec();

    // the examples are a cartesian product of the following constraints
    // e.g. Len/Len, Len/Min, Len/Max, Len/Perc, Len/Ratio, Min/Len, Min/Min, ...
    let examples = [
        (
            "Len",
            vec![
                Length(0),
                Length(2),
                Length(3),
                Length(6),
                Length(10),
                Length(15),
            ],
        ),
        (
            "Min",
            vec![Min(0), Min(2), Min(3), Min(6), Min(10), Min(15)],
        ),
        (
            "Max",
            vec![Max(0), Max(2), Max(3), Max(6), Max(10), Max(15)],
        ),
        (
            "Perc",
            vec![
                Percentage(0),
                Percentage(25),
                Percentage(50),
                Percentage(75),
                Percentage(100),
                Percentage(150),
            ],
        ),
        (
            "Ratio",
            vec![
                Ratio(0, 4),
                Ratio(1, 4),
                Ratio(2, 4),
                Ratio(3, 4),
                Ratio(4, 4),
                Ratio(6, 4),
            ],
        ),
    ];

    for (i, (a, b)) in examples
        .iter()
        .cartesian_product(examples.iter())
        .enumerate()
    {
        let (name_a, examples_a) = a;
        let (name_b, examples_b) = b;
        let constraints = examples_a
            .iter()
            .copied()
            .zip(examples_b.iter().copied())
            .collect_vec();
        render_example_combination(
            frame,
            example_areas[i],
            &format!("{name_a}/{name_b}"),
            constraints,
        );
    }
}