Struct Dialog 

pub struct Dialog {
    pub open: bool,
    pub submitted: bool,
    pub working_input: String,
    pub submitted_input: String,
    /* private fields */
}

The data structure for the dialog.

Fields

open: bool

Whether or not the dialog box is open.

submitted: bool

Whether or not input has been submitted.

working_input: String

The text being written into the dialog box when it’s open. This field can be used to pre-populate the dialog with a value before it is opened. It will be cleared when the user presses Esc or Enter.

submitted_input: String

The text that has been written and is submitted for use when the user presses Enter. Any surrounding whitespace will be trimmed.

Implementations

impl Dialog

pub fn key_action(&mut self, key_code: &KeyCode)

Respond to key press.

Examples found in repository

examples/basic.rs (line 87)

fn run(
    app: &mut App,
    terminal: &mut Terminal<CrosstermBackend<Stdout>>,
) -> Result<(), std::io::Error> {
    while !app.exit {
        // Redraw the frame every time.
        terminal.draw(|frame| render(frame, app))?;

        // Handle user input.
        match event::read()? {
            Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
                // Pass all `key_event.code`s to a dialog if open.
                // (The dialog handles closing itself, when the user presses `Enter` or `Esc`.)
                if app.dialog.open {
                    app.dialog.key_action(&key_event.code);
                    if app.dialog.submitted {
                        // Here is where you'd do something more significant.
                        app.text = app.dialog.submitted_input.clone();
                    }
                // Otherwise handle them here.
                } else {
                    match key_event.code {
                        KeyCode::Char('q') => app.exit = true,
                        // Your app needs to open the dialog.
                        KeyCode::Char('d') => app.dialog.open = true,
                        _ => (),
                    }
                }
            }
            _ => (),
        };
    }
    Ok(())
}

pub fn title_top(&mut self, title: &str) -> Self

Set the top title of the block surrounding the widget.

If the method is not used, there will be no top title.

Examples found in repository

examples/basic.rs (line 137)

fn render(frame: &mut Frame, app: &mut App) {
    // Layout the rectangles of the UI.
    let horizontal = Layout::horizontal([Constraint::Fill(1), Constraint::Length(SIDEBAR_SIZE)]);

    let [left, right] = horizontal.areas(frame.area());

    // Left - main content.
    let main_block = Block::default()
        .title_top(Line::from(" tui-dialog example ").bold().centered())
        .borders(Borders::ALL)
        .border_set(border::THICK)
        .padding(Padding::horizontal(1));

    // Right - Controls menu
    let controls_block = Block::default()
        .title_top(Line::from(" Controls").centered().bold())
        .borders(Borders::ALL)
        .border_set(border::THICK);

    let controls_content: Vec<Line<'_>> = vec![
        vec!["d".blue(), " Show dialog".into()].into(),
        vec!["q".blue(), " Quit".into()].into(),
    ];

    let controls = Paragraph::new(controls_content).block(controls_block);
    frame.render_widget(controls, right);
    frame.render_widget(Paragraph::new(app.text.clone()).block(main_block), left);

    let dialog_area = centered_rect(frame.area(), 45, 5, -(SIDEBAR_SIZE as i16), 0);
    frame.render_widget(app.dialog.title_top("Enter text:"), dialog_area);
}

pub fn title_bottom(&mut self, title: &str) -> Self

Set the bottom title of the block surrounding the widget.

If the method is not used, the bottom title will default to BOTTOM_TITLE.

pub fn borders(&mut self, borders: Borders) -> Self

Set borders of the block surrounding the widget.

If the method is not used, the borders will default to ratatui::widgets::Borders::ALL.

pub fn style(&mut self, style: Style) -> Self

Set the style of the widget.

If the method is not used, the style will be the default with a ratatui::style::Color::DarkGray background.

Trait Implementations

impl Clone for Dialog

fn clone(&self) -> Dialog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Dialog

fn default() -> Dialog

Returns the “default value” for a type.

impl PartialEq for Dialog

fn eq(&self, other: &Dialog) -> 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 Widget for Dialog

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.

impl StructuralPartialEq for Dialog