Struct Popup 

#[non_exhaustive]
pub struct Popup<'content, W> {
    pub body: W,
    pub title: Line<'content>,
    pub style: Style,
    pub borders: Borders,
    pub border_set: Set<'content>,
    pub border_style: Style,
}

Configuration for a popup.

This struct is used to configure a Popup. It can be created using Popup::new.

Example

use ratatui::prelude::*;
use ratatui::symbols::border;
use tui_popup::Popup;

fn render_popup(frame: &mut Frame) {
    let popup = Popup::new("Press any key to exit")
        .title("tui-popup demo")
        .style(Style::new().white().on_blue())
        .border_set(border::ROUNDED)
        .border_style(Style::new().bold());
    frame.render_widget(popup, frame.area());
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

body: W

The body of the popup.

title: Line<'content>

The title of the popup.

style: Style

The style to apply to the entire popup.

borders: Borders

The borders of the popup.

border_set: Set<'content>

The symbols used to render the border.

border_style: Style

Border style

Implementations

impl<'content, W> Popup<'content, W>

pub fn title(self, value: impl Into<Line<'content>>) -> Self

Sets the title field of this struct.

Examples found in repository

examples/popup.rs (line 32)

fn render(frame: &mut Frame) {
    let area = frame.area();
    let background = background(area);
    let popup = Popup::new("Press any key to exit")
        .title("tui-popup demo")
        .style(Style::new().white().on_blue());
    frame.render_widget(background, area);
    frame.render_widget(popup, area);
}

examples/state.rs (line 54)

fn render_popup(frame: &mut Frame, area: Rect, state: &mut PopupState) {
    let body = Text::from_iter([
        "q: exit",
        "r: reset",
        "j: move down",
        "k: move up",
        "h: move left",
        "l: move right",
    ]);
    let popup = Popup::new(body)
        .title("Popup")
        .style(Style::new().white().on_blue());
    frame.render_stateful_widget(popup, area, state);
}

examples/paragraph.rs (line 55)

    fn render_popup(&self, frame: &mut Frame) {
        let lines: Text = (0..10).map(|i| Span::raw(format!("Line {i}"))).collect();
        let paragraph = Paragraph::new(lines).scroll((self.scroll, 0));
        let wrapper = KnownSizeWrapper {
            inner: paragraph,
            width: 21,
            height: 5,
        };
        let popup = Popup::new(wrapper)
            .title("scroll: ↑/↓ quit: Esc")
            .style(Style::new().white().on_blue());
        frame.render_widget(popup, frame.area());
    }

pub fn style(self, value: impl Into<Style>) -> Self

Sets the style field of this struct.

Examples found in repository

examples/popup.rs (line 33)

fn render(frame: &mut Frame) {
    let area = frame.area();
    let background = background(area);
    let popup = Popup::new("Press any key to exit")
        .title("tui-popup demo")
        .style(Style::new().white().on_blue());
    frame.render_widget(background, area);
    frame.render_widget(popup, area);
}

examples/state.rs (line 55)

fn render_popup(frame: &mut Frame, area: Rect, state: &mut PopupState) {
    let body = Text::from_iter([
        "q: exit",
        "r: reset",
        "j: move down",
        "k: move up",
        "h: move left",
        "l: move right",
    ]);
    let popup = Popup::new(body)
        .title("Popup")
        .style(Style::new().white().on_blue());
    frame.render_stateful_widget(popup, area, state);
}

examples/paragraph.rs (line 56)

    fn render_popup(&self, frame: &mut Frame) {
        let lines: Text = (0..10).map(|i| Span::raw(format!("Line {i}"))).collect();
        let paragraph = Paragraph::new(lines).scroll((self.scroll, 0));
        let wrapper = KnownSizeWrapper {
            inner: paragraph,
            width: 21,
            height: 5,
        };
        let popup = Popup::new(wrapper)
            .title("scroll: ↑/↓ quit: Esc")
            .style(Style::new().white().on_blue());
        frame.render_widget(popup, frame.area());
    }

pub fn borders(self, value: impl Into<Borders>) -> Self

Sets the borders field of this struct.

pub fn border_set(self, value: impl Into<Set<'content>>) -> Self

Sets the border_set field of this struct.

pub fn border_style(self, value: impl Into<Style>) -> Self

Sets the border_style field of this struct.

impl<W> Popup<'_, W>

pub fn new(body: W) -> Self

Create a new popup with the given title and body with all the borders.

Parameters

• body - The body of the popup. This can be any type that can be converted into a Text.

Example

use tui_popup::Popup;

let popup = Popup::new("Press any key to exit").title("tui-popup demo");

Examples found in repository

examples/popup.rs (line 31)

fn render(frame: &mut Frame) {
    let area = frame.area();
    let background = background(area);
    let popup = Popup::new("Press any key to exit")
        .title("tui-popup demo")
        .style(Style::new().white().on_blue());
    frame.render_widget(background, area);
    frame.render_widget(popup, area);
}

examples/state.rs (line 53)

fn render_popup(frame: &mut Frame, area: Rect, state: &mut PopupState) {
    let body = Text::from_iter([
        "q: exit",
        "r: reset",
        "j: move down",
        "k: move up",
        "h: move left",
        "l: move right",
    ]);
    let popup = Popup::new(body)
        .title("Popup")
        .style(Style::new().white().on_blue());
    frame.render_stateful_widget(popup, area, state);
}

examples/paragraph.rs (line 54)

    fn render_popup(&self, frame: &mut Frame) {
        let lines: Text = (0..10).map(|i| Span::raw(format!("Line {i}"))).collect();
        let paragraph = Paragraph::new(lines).scroll((self.scroll, 0));
        let wrapper = KnownSizeWrapper {
            inner: paragraph,
            width: 21,
            height: 5,
        };
        let popup = Popup::new(wrapper)
            .title("scroll: ↑/↓ quit: Esc")
            .style(Style::new().white().on_blue());
        frame.render_widget(popup, frame.area());
    }

Trait Implementations

impl<W> Debug for Popup<'_, W>

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

Formats the value using the given formatter.

impl<W: PartialEq> PartialEq for Popup<'_, W>

fn eq(&self, other: &Self) -> 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<W> StatefulWidget for &Popup<'_, W>

where W: KnownSize, for<'a> &'a W: Widget,

Reference stateful render path for a popup body that renders by reference.

Use this when you have long-lived popup data and want to update PopupState without moving the popup each frame. This requires the body to support rendering by reference.

Example

let popup = Popup::new(Text::from("Body"));
let popup_ref = &popup;
let mut state = PopupState::default();
popup_ref.render(buffer.area, &mut buffer, &mut state);

type State = PopupState

State associated with the stateful widget.

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

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

impl<W: KnownSize + Widget> StatefulWidget for Popup<'_, W>

Owned stateful render path for a popup.

Use this when you have a PopupState that you want to update across frames and you can pass the popup by value in the render call.

Example

let popup = Popup::new("Body");
let mut state = PopupState::default();
popup.render(buffer.area, &mut buffer, &mut state);

type State = PopupState

State associated with the stateful widget.

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

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

impl<W> Widget for &Popup<'_, W>

where W: KnownSize, for<'a> &'a W: Widget,

Reference render path for a popup body that supports rendering by reference.

Use this when you want to keep a Popup around and render it by reference. This is helpful when the body implements Widget for references (such as Text), or when you need to avoid rebuilding the widget each frame.

Example

let popup = Popup::new(Text::from("Body"));
let popup_ref = &popup;
popup_ref.render(buffer.area, &mut buffer);

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<W: KnownSize + Widget> Widget for Popup<'_, W>

Owned render path for a popup.

Use this when you have an owned Popup value and want to render it by value. This is the simplest option for new users, and it works well with common bodies like &str or String.

Example

let popup = Popup::new("Body");
popup.render(buffer.area, &mut buffer);

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.