Struct Theme 

pub struct Theme {

    pub palette: Palette,
    pub symbols: Symbols,
    pub text: Style,
    pub muted: Style,
    pub accent: Style,
    pub success: Style,
    pub warning: Style,
    pub error: Style,
    pub border: Style,
    pub focused_border: Style,
    pub title: Style,
    pub selected: Style,
    pub help_key: Style,
    pub help_desc: Style,
}

Semantic style tokens and widget helpers for a Charm-like ratatui UI.

Fields

palette: Palette

Source palette used to build semantic styles.

symbols: Symbols

Shared symbols used by helper methods.

text: Style

Main text style.

muted: Style

Muted secondary text style.

accent: Style

Primary accent style.

success: Style

Success style.

warning: Style

Warning style.

error: Style

Error style.

border: Style

Normal border style.

focused_border: Style

Focused border style.

title: Style

Block title style.

selected: Style

Selected row/item style.

help_key: Style

Help key style.

help_desc: Style

Help description style.

Implementations

impl Theme

pub fn new(palette: Palette, symbols: Symbols) -> Self

Builds a theme from a palette and symbol set.

pub fn block<'a>(&self) -> Block<'a>

Creates a rounded bordered block using the theme’s default border and title styles.

pub fn block_with_focus<'a>(&self, focused: bool) -> Block<'a>

Creates a rounded bordered block with focus-aware border styling.

Examples found in repository

examples/themed-widgets.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let theme = BubbleTheme::default();
    let backend = TestBackend::new(48, 8);
    let mut terminal = Terminal::new(backend)?;

    terminal.draw(|frame| {
        let area = frame.area();
        let inner = area.inner(Margin::new(2, 1));

        frame.render_widget(
            theme
                .block_with_focus(true)
                .title(theme.title("ratatui-bubbletea")),
            area,
        );

        frame.render_widget(
            theme.paragraph(vec![
                theme.bullet("Plain ratatui loop"),
                theme.checked("Charm-like defaults"),
                theme.help_line([("q", "quit"), ("?", "help")]),
            ]),
            inner,
        );
    })?;

    Ok(())
}

pub fn titled_block<'a, T>(&self, title: T) -> Block<'a>

where T: Into<Line<'a>>,

Creates a rounded, titled block using the theme’s default title style.

pub fn modal_block<'a>(&self) -> Block<'a>

Creates a modal-style block with the focused/accent border style.

This is intended for the common Clear + centered-popup pattern.

pub fn titled_modal_block<'a, T>(&self, title: T) -> Block<'a>

where T: Into<Line<'a>>,

Creates a titled modal-style block with the focused/accent border style.

pub fn paragraph<'a, T>(&self, text: T) -> Paragraph<'a>

where T: Into<Text<'a>>,

Creates a paragraph using the theme’s normal text style.

Examples found in repository

examples/themed-widgets.rs (lines 23-27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let theme = BubbleTheme::default();
    let backend = TestBackend::new(48, 8);
    let mut terminal = Terminal::new(backend)?;

    terminal.draw(|frame| {
        let area = frame.area();
        let inner = area.inner(Margin::new(2, 1));

        frame.render_widget(
            theme
                .block_with_focus(true)
                .title(theme.title("ratatui-bubbletea")),
            area,
        );

        frame.render_widget(
            theme.paragraph(vec![
                theme.bullet("Plain ratatui loop"),
                theme.checked("Charm-like defaults"),
                theme.help_line([("q", "quit"), ("?", "help")]),
            ]),
            inner,
        );
    })?;

    Ok(())
}

pub fn paragraph_in_block<'a, T, L>(&self, text: T, title: L) -> Paragraph<'a>

where T: Into<Text<'a>>, L: Into<Line<'a>>,

Creates a paragraph with a themed block attached.

pub fn span<'a, T>(&self, content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Creates a normal text span.

pub fn muted<'a, T>(&self, content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Creates a muted text span.

pub fn accent<'a, T>(&self, content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Creates an accent text span.

pub fn success<'a, T>(&self, content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Creates a success text span.

pub fn warning<'a, T>(&self, content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Creates a warning text span.

pub fn error<'a, T>(&self, content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Creates an error text span.

pub fn title<'a, T>(&self, content: T) -> Line<'a>

where T: Into<Cow<'a, str>>,

Creates a title line.

Examples found in repository

examples/themed-widgets.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let theme = BubbleTheme::default();
    let backend = TestBackend::new(48, 8);
    let mut terminal = Terminal::new(backend)?;

    terminal.draw(|frame| {
        let area = frame.area();
        let inner = area.inner(Margin::new(2, 1));

        frame.render_widget(
            theme
                .block_with_focus(true)
                .title(theme.title("ratatui-bubbletea")),
            area,
        );

        frame.render_widget(
            theme.paragraph(vec![
                theme.bullet("Plain ratatui loop"),
                theme.checked("Charm-like defaults"),
                theme.help_line([("q", "quit"), ("?", "help")]),
            ]),
            inner,
        );
    })?;

    Ok(())
}

pub fn bullet<'a, T>(&self, content: T) -> Line<'a>

where T: Into<Cow<'a, str>>,

Creates a line prefixed with the default bullet symbol.

Examples found in repository

examples/themed-widgets.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let theme = BubbleTheme::default();
    let backend = TestBackend::new(48, 8);
    let mut terminal = Terminal::new(backend)?;

    terminal.draw(|frame| {
        let area = frame.area();
        let inner = area.inner(Margin::new(2, 1));

        frame.render_widget(
            theme
                .block_with_focus(true)
                .title(theme.title("ratatui-bubbletea")),
            area,
        );

        frame.render_widget(
            theme.paragraph(vec![
                theme.bullet("Plain ratatui loop"),
                theme.checked("Charm-like defaults"),
                theme.help_line([("q", "quit"), ("?", "help")]),
            ]),
            inner,
        );
    })?;

    Ok(())
}

pub fn checked<'a, T>(&self, content: T) -> Line<'a>

where T: Into<Cow<'a, str>>,

Creates a success line prefixed with the default check symbol.

Examples found in repository

examples/themed-widgets.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let theme = BubbleTheme::default();
    let backend = TestBackend::new(48, 8);
    let mut terminal = Terminal::new(backend)?;

    terminal.draw(|frame| {
        let area = frame.area();
        let inner = area.inner(Margin::new(2, 1));

        frame.render_widget(
            theme
                .block_with_focus(true)
                .title(theme.title("ratatui-bubbletea")),
            area,
        );

        frame.render_widget(
            theme.paragraph(vec![
                theme.bullet("Plain ratatui loop"),
                theme.checked("Charm-like defaults"),
                theme.help_line([("q", "quit"), ("?", "help")]),
            ]),
            inner,
        );
    })?;

    Ok(())
}

pub fn crossed<'a, T>(&self, content: T) -> Line<'a>

where T: Into<Cow<'a, str>>,

Creates an error line prefixed with the default cross symbol.

pub fn help_line<'a, I, K, D>(&self, bindings: I) -> Line<'a>

where I: IntoIterator<Item = (K, D)>, K: Into<Cow<'a, str>>, D: Into<Cow<'a, str>>,

Creates a compact help line from (key, description) pairs.

Examples found in repository

examples/themed-widgets.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let theme = BubbleTheme::default();
    let backend = TestBackend::new(48, 8);
    let mut terminal = Terminal::new(backend)?;

    terminal.draw(|frame| {
        let area = frame.area();
        let inner = area.inner(Margin::new(2, 1));

        frame.render_widget(
            theme
                .block_with_focus(true)
                .title(theme.title("ratatui-bubbletea")),
            area,
        );

        frame.render_widget(
            theme.paragraph(vec![
                theme.bullet("Plain ratatui loop"),
                theme.checked("Charm-like defaults"),
                theme.help_line([("q", "quit"), ("?", "help")]),
            ]),
            inner,
        );
    })?;

    Ok(())
}

Trait Implementations

impl Clone for Theme

fn clone(&self) -> Theme

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Theme

impl Debug for Theme

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

Formats the value using the given formatter.

impl Default for Theme

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Theme

impl Hash for Theme

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Theme

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