Struct Style 

pub struct Style {
    pub fg: Option<Color>,
    pub bg: Option<Color>,
    pub underline_color: Option<Color>,
    pub add_modifier: Modifier,
    pub sub_modifier: Modifier,
}

Style lets you control the main characteristics of the displayed elements.

use ratatui_core::style::{Color, Modifier, Style};

Style::default()
    .fg(Color::Black)
    .bg(Color::Green)
    .add_modifier(Modifier::ITALIC | Modifier::BOLD);

Styles can also be created with a shorthand notation.

use ratatui_core::style::{Style, Stylize};

Style::new().black().on_green().italic().bold();

For more information about the style shorthands, see the Stylize trait.

We implement conversions from Color and Modifier to Style so you can use them anywhere that accepts Into<Style>.

use ratatui_core::style::{Color, Modifier, Style};
use ratatui_core::text::Line;

Line::styled("hello", Style::new().fg(Color::Red));
// simplifies to
Line::styled("hello", Color::Red);

Line::styled("hello", Style::new().add_modifier(Modifier::BOLD));
// simplifies to
Line::styled("hello", Modifier::BOLD);

Styles represents an incremental change. If you apply the styles S1, S2, S3 to a cell of the terminal buffer, the style of this cell will be the result of the merge of S1, S2 and S3, not just S3.

use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;
use ratatui_core::style::{Color, Modifier, Style};

let styles = [
    Style::default()
        .fg(Color::Blue)
        .add_modifier(Modifier::BOLD | Modifier::ITALIC),
    Style::default()
        .bg(Color::Red)
        .add_modifier(Modifier::UNDERLINED),
    #[cfg(feature = "underline-color")]
    Style::default().underline_color(Color::Green),
    Style::default()
        .fg(Color::Yellow)
        .remove_modifier(Modifier::ITALIC),
];
let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
for style in &styles {
    buffer[(0, 0)].set_style(*style);
}
assert_eq!(
    Style {
        fg: Some(Color::Yellow),
        bg: Some(Color::Red),
        #[cfg(feature = "underline-color")]
        underline_color: Some(Color::Green),
        add_modifier: Modifier::BOLD | Modifier::UNDERLINED,
        sub_modifier: Modifier::empty(),
    },
    buffer[(0, 0)].style(),
);

The default implementation returns a Style that does not modify anything. If you wish to reset all properties until that point use Style::reset.

use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;
use ratatui_core::style::{Color, Modifier, Style};

let styles = [
    Style::default()
        .fg(Color::Blue)
        .add_modifier(Modifier::BOLD | Modifier::ITALIC),
    Style::reset().fg(Color::Yellow),
];
let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
for style in &styles {
    buffer[(0, 0)].set_style(*style);
}
assert_eq!(
    Style {
        fg: Some(Color::Yellow),
        bg: Some(Color::Reset),
        #[cfg(feature = "underline-color")]
        underline_color: Some(Color::Reset),
        add_modifier: Modifier::empty(),
        sub_modifier: Modifier::empty(),
    },
    buffer[(0, 0)].style(),
);

Fields

fg: Option<Color>

The foreground color.

bg: Option<Color>

The background color.

underline_color: Option<Color>

The underline color.

add_modifier: Modifier

The modifiers to add.

sub_modifier: Modifier

The modifiers to remove.

Implementations

impl Style

pub const fn new() -> Style

Returns a Style with default properties.

pub const fn reset() -> Style

Returns a Style resetting all properties.

pub const fn fg(self, color: Color) -> Style

Changes the foreground color.

Examples

use ratatui_core::style::{Color, Style};

let style = Style::default().fg(Color::Blue);
let diff = Style::default().fg(Color::Red);
assert_eq!(style.patch(diff), Style::default().fg(Color::Red));

pub const fn bg(self, color: Color) -> Style

Changes the background color.

Examples

use ratatui_core::style::{Color, Style};

let style = Style::default().bg(Color::Blue);
let diff = Style::default().bg(Color::Red);
assert_eq!(style.patch(diff), Style::default().bg(Color::Red));

pub const fn underline_color(self, color: Color) -> Style

Changes the underline color. The text must be underlined with a modifier for this to work.

This uses a non-standard ANSI escape sequence. It is supported by most terminal emulators, but is only implemented in the crossterm backend and enabled by the underline-color feature flag.

See Wikipedia code 58 and 59 for more information.

Examples

use ratatui_core::style::{Color, Modifier, Style};

let style = Style::default()
    .underline_color(Color::Blue)
    .add_modifier(Modifier::UNDERLINED);
let diff = Style::default()
    .underline_color(Color::Red)
    .add_modifier(Modifier::UNDERLINED);
assert_eq!(
    style.patch(diff),
    Style::default()
        .underline_color(Color::Red)
        .add_modifier(Modifier::UNDERLINED)
);

pub const fn add_modifier(self, modifier: Modifier) -> Style

Changes the text emphasis.

When applied, it adds the given modifier to the Style modifiers.

Examples

use ratatui_core::style::{Modifier, Style};

let style = Style::default().add_modifier(Modifier::BOLD);
let diff = Style::default().add_modifier(Modifier::ITALIC);
let patched = style.patch(diff);
assert_eq!(patched.add_modifier, Modifier::BOLD | Modifier::ITALIC);
assert_eq!(patched.sub_modifier, Modifier::empty());

pub const fn remove_modifier(self, modifier: Modifier) -> Style

Changes the text emphasis.

When applied, it removes the given modifier from the Style modifiers.

Examples

use ratatui_core::style::{Modifier, Style};

let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
let diff = Style::default().remove_modifier(Modifier::ITALIC);
let patched = style.patch(diff);
assert_eq!(patched.add_modifier, Modifier::BOLD);
assert_eq!(patched.sub_modifier, Modifier::ITALIC);

pub const fn has_modifier(self, modifier: Modifier) -> bool

Returns true if the style has the given modifier set.

Examples

use ratatui_core::style::{Modifier, Style};

let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
assert!(style.has_modifier(Modifier::BOLD));
assert!(style.has_modifier(Modifier::ITALIC));
assert!(!style.has_modifier(Modifier::UNDERLINED));

pub fn patch<S>(self, other: S) -> Style

where S: Into<Style>,

Results in a combined style that is equivalent to applying the two individual styles to a style one after the other.

style accepts any type that is convertible to Style (e.g. Style, Color, or your own type that implements Into<Style>).

Examples

use ratatui_core::style::{Color, Modifier, Style};

let style_1 = Style::default().fg(Color::Yellow);
let style_2 = Style::default().bg(Color::Red);
let combined = style_1.patch(style_2);
assert_eq!(
    Style::default().patch(style_1).patch(style_2),
    Style::default().patch(combined)
);

pub const fn black(self) -> Style

Sets the foreground color to black.

pub const fn on_black(self) -> Style

Sets the background color to black.

pub const fn red(self) -> Style

Sets the foreground color to red.

pub const fn on_red(self) -> Style

Sets the background color to red.

pub const fn green(self) -> Style

Sets the foreground color to green.

pub const fn on_green(self) -> Style

Sets the background color to green.

pub const fn yellow(self) -> Style

Sets the foreground color to yellow.

pub const fn on_yellow(self) -> Style

Sets the background color to yellow.

pub const fn blue(self) -> Style

Sets the foreground color to blue.

pub const fn on_blue(self) -> Style

Sets the background color to blue.

pub const fn magenta(self) -> Style

Sets the foreground color to magenta.

pub const fn on_magenta(self) -> Style

Sets the background color to magenta.

pub const fn cyan(self) -> Style

Sets the foreground color to cyan.

pub const fn on_cyan(self) -> Style

Sets the background color to cyan.

pub const fn gray(self) -> Style

Sets the foreground color to gray.

pub const fn on_gray(self) -> Style

Sets the background color to gray.

pub const fn dark_gray(self) -> Style

Sets the foreground color to dark_gray.

pub const fn on_dark_gray(self) -> Style

Sets the background color to dark_gray.

pub const fn light_red(self) -> Style

Sets the foreground color to light_red.

pub const fn on_light_red(self) -> Style

Sets the background color to light_red.

pub const fn light_green(self) -> Style

Sets the foreground color to light_green.

pub const fn on_light_green(self) -> Style

Sets the background color to light_green.

pub const fn light_yellow(self) -> Style

Sets the foreground color to light_yellow.

pub const fn on_light_yellow(self) -> Style

Sets the background color to light_yellow.

pub const fn light_blue(self) -> Style

Sets the foreground color to light_blue.

pub const fn on_light_blue(self) -> Style

Sets the background color to light_blue.

pub const fn light_magenta(self) -> Style

Sets the foreground color to light_magenta.

pub const fn on_light_magenta(self) -> Style

Sets the background color to light_magenta.

pub const fn light_cyan(self) -> Style

Sets the foreground color to light_cyan.

pub const fn on_light_cyan(self) -> Style

Sets the background color to light_cyan.

pub const fn white(self) -> Style

Sets the foreground color to white.

pub const fn on_white(self) -> Style

Sets the background color to white.

pub const fn bold(self) -> Style

Adds the bold modifier.

pub const fn not_bold(self) -> Style

Removes the bold modifier.

pub const fn dim(self) -> Style

Adds the dim modifier.

pub const fn not_dim(self) -> Style

Removes the dim modifier.

pub const fn italic(self) -> Style

Adds the italic modifier.

pub const fn not_italic(self) -> Style

Removes the italic modifier.

pub const fn underlined(self) -> Style

Adds the underlined modifier.

pub const fn not_underlined(self) -> Style

Removes the underlined modifier.

pub const fn slow_blink(self) -> Style

Adds the slow_blink modifier.

pub const fn not_slow_blink(self) -> Style

Removes the slow_blink modifier.

pub const fn rapid_blink(self) -> Style

Adds the rapid_blink modifier.

pub const fn not_rapid_blink(self) -> Style

Removes the rapid_blink modifier.

pub const fn reversed(self) -> Style

Adds the reversed modifier.

pub const fn not_reversed(self) -> Style

Removes the reversed modifier.

pub const fn hidden(self) -> Style

Adds the hidden modifier.

pub const fn not_hidden(self) -> Style

Removes the hidden modifier.

pub const fn crossed_out(self) -> Style

Adds the crossed_out modifier.

pub const fn not_crossed_out(self) -> Style

Removes the crossed_out modifier.

Trait Implementations

impl Clone for Style

fn clone(&self) -> Style

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Style

A custom debug implementation that prints only the fields that are not the default, and unwraps the Options.

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Style

Returns the “default value” for a type.

impl From<(Color, Color)> for Style

fn from(_: (Color, Color)) -> Style

Creates a new Style with the given foreground and background colors.

Example

use ratatui_core::style::{Color, Style};

// red foreground, blue background
let style = Style::from((Color::Red, Color::Blue));
// default foreground, blue background
let style = Style::from((Color::Reset, Color::Blue));

impl From<(Color, Color, Modifier)> for Style

fn from(_: (Color, Color, Modifier)) -> Style

Creates a new Style with the given foreground and background colors and modifier added.

To specify multiple modifiers, use the | operator.

Example

use ratatui_core::style::{Color, Modifier, Style};

// red foreground, blue background, add bold and italic
let style = Style::from((Color::Red, Color::Blue, Modifier::BOLD | Modifier::ITALIC));

impl From<(Color, Color, Modifier, Modifier)> for Style

fn from(_: (Color, Color, Modifier, Modifier)) -> Style

Creates a new Style with the given foreground and background colors and modifiers added and removed.

Example

use ratatui_core::style::{Color, Modifier, Style};

// red foreground, blue background, add bold and italic, remove dim
let style = Style::from((
    Color::Red,
    Color::Blue,
    Modifier::BOLD | Modifier::ITALIC,
    Modifier::DIM,
));

impl From<(Color, Modifier)> for Style

fn from(_: (Color, Modifier)) -> Style

Creates a new Style with the given foreground color and modifier added.

To specify multiple modifiers, use the | operator.

Example

use ratatui_core::style::{Color, Modifier, Style};

// red foreground, add bold and italic
let style = Style::from((Color::Red, Modifier::BOLD | Modifier::ITALIC));

impl From<(Modifier, Modifier)> for Style

fn from(_: (Modifier, Modifier)) -> Style

Creates a new Style with the given modifiers added and removed.

Example

use ratatui_core::style::{Modifier, Style};

// add bold and italic, remove dim
let style = Style::from((Modifier::BOLD | Modifier::ITALIC, Modifier::DIM));

impl From<Color> for Style

fn from(color: Color) -> Style

Creates a new Style with the given foreground color.

To specify a foreground and background color, use the from((fg, bg)) constructor.

Example

use ratatui_core::style::{Color, Style};

let style = Style::from(Color::Red);

impl From<Modifier> for Style

fn from(modifier: Modifier) -> Style

Creates a new Style with the given modifier added.

To specify multiple modifiers, use the | operator.

To specify modifiers to add and remove, use the from((add_modifier, sub_modifier)) constructor.

Example

use ratatui_core::style::{Style, Modifier};

// add bold and italic
let style = Style::from(Modifier::BOLD|Modifier::ITALIC);

impl FromCrossterm<ContentStyle> for Style

fn from_crossterm(value: ContentStyle) -> Style

Converts the crossterm type to a ratatui type.

impl Hash for Style

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

where __H: Hasher,

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 Style

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

impl Eq for Style

impl StructuralPartialEq for Style