Struct ratatui::text::Masked

pub struct Masked<'a> { /* private fields */ }

A wrapper around a string that is masked when displayed.

The masked string is displayed as a series of the same character. This might be used to display a password field or similar secure data.

Examples

use ratatui::{buffer::Buffer, layout::Rect, text::Masked, widgets::{Paragraph, Widget}};

let mut buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
let password = Masked::new("12345", 'x');

Paragraph::new(password).render(buffer.area, &mut buffer);
assert_eq!(buffer, Buffer::with_lines(vec!["xxxxx"]));

Implementations

impl<'a> Masked<'a>

pub fn new(s: impl Into<Cow<'a, str>>, mask_char: char) -> Self

Examples found in repository

examples/paragraph.rs (line 139)

fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
    let size = f.size();

    // Words made "loooong" to demonstrate line breaking.
    let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
    let mut long_line = s.repeat(usize::from(size.width) / s.len() + 4);
    long_line.push('\n');

    let block = Block::default().style(Style::default().fg(Color::Black));
    f.render_widget(block, size);

    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .margin(2)
        .constraints(
            [
                Constraint::Percentage(25),
                Constraint::Percentage(25),
                Constraint::Percentage(25),
                Constraint::Percentage(25),
            ]
            .as_ref(),
        )
        .split(size);

    let text = vec![
        Line::from("This is a line "),
        Line::from(Span::styled(
            "This is a line   ",
            Style::default().fg(Color::Red),
        )),
        Line::from(Span::styled(
            "This is a line",
            Style::default().bg(Color::Blue),
        )),
        Line::from(Span::styled(
            "This is a longer line",
            Style::default().add_modifier(Modifier::CROSSED_OUT),
        )),
        Line::from(Span::styled(&long_line, Style::default().bg(Color::Green))),
        Line::from(Span::styled(
            "This is a line",
            Style::default()
                .fg(Color::Green)
                .add_modifier(Modifier::ITALIC),
        )),
        Line::from(vec![
            Span::raw("Masked text: "),
            Span::styled(
                Masked::new("password", '*'),
                Style::default().fg(Color::Red),
            ),
        ]),
    ];

    let create_block = |title| {
        Block::default()
            .borders(Borders::ALL)
            .style(Style::default().fg(Color::Gray))
            .title(Span::styled(
                title,
                Style::default().add_modifier(Modifier::BOLD),
            ))
    };

    let paragraph = Paragraph::new(text.clone())
        .style(Style::default().fg(Color::Gray))
        .block(create_block("Default alignment (Left), no wrap"));
    f.render_widget(paragraph, chunks[0]);

    let paragraph = Paragraph::new(text.clone())
        .style(Style::default().fg(Color::Gray))
        .block(create_block("Default alignment (Left), with wrap"))
        .wrap(Wrap { trim: true });
    f.render_widget(paragraph, chunks[1]);

    let paragraph = Paragraph::new(text.clone())
        .style(Style::default().fg(Color::Gray))
        .block(create_block("Right alignment, with wrap"))
        .alignment(Alignment::Right)
        .wrap(Wrap { trim: true });
    f.render_widget(paragraph, chunks[2]);

    let paragraph = Paragraph::new(text)
        .style(Style::default().fg(Color::Gray))
        .block(create_block("Center alignment, with wrap, with scroll"))
        .alignment(Alignment::Center)
        .wrap(Wrap { trim: true })
        .scroll((app.scroll, 0));
    f.render_widget(paragraph, chunks[3]);
}

pub fn mask_char(&self) -> char

The character to use for masking.

pub fn value(&self) -> Cow<'a, str>

The underlying string, with all characters masked.

Trait Implementations

impl<'a> Clone for Masked<'a>

fn clone(&self) -> Masked<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Masked<'_>

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

Debug representation of a masked string is the underlying string

impl Display for Masked<'_>

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

Display representation of a masked string is the masked string

impl<'a> From<&'a Masked<'_>> for Text<'a>

fn from(masked: &'a Masked<'_>) -> Text<'a>

Converts to this type from the input type.

impl<'a> From<&'a Masked<'a>> for Cow<'a, str>

fn from(masked: &'a Masked<'_>) -> Cow<'a, str>

Converts to this type from the input type.

impl<'a> From<Masked<'a>> for Cow<'a, str>

fn from(masked: Masked<'a>) -> Cow<'a, str>

Converts to this type from the input type.

impl<'a> From<Masked<'a>> for Text<'a>

fn from(masked: Masked<'a>) -> Text<'a>

Converts to this type from the input type.