Enum Color 

pub enum Color {
    Reset,
    Black,
    Red,
    Green,
    Yellow,
    Blue,
    Magenta,
    Cyan,
    Gray,
    DarkGray,
    LightRed,
    LightGreen,
    LightYellow,
    LightBlue,
    LightMagenta,
    LightCyan,
    White,
    Rgb(u8, u8, u8),
    Indexed(u8),
}

ANSI Color

All colors from the ANSI color table are supported (though some names are not exactly the same).

Color Name	Color	Foreground	Background
black	Color::Black	30	40
red	Color::Red	31	41
green	Color::Green	32	42
yellow	Color::Yellow	33	43
blue	Color::Blue	34	44
magenta	Color::Magenta	35	45
cyan	Color::Cyan	36	46
gray*	Color::Gray	37	47
darkgray*	Color::DarkGray	90	100
lightred	Color::LightRed	91	101
lightgreen	Color::LightGreen	92	102
lightyellow	Color::LightYellow	93	103
lightblue	Color::LightBlue	94	104
lightmagenta	Color::LightMagenta	95	105
lightcyan	Color::LightCyan	96	106
white*	Color::White	97	107

• gray is sometimes called white - this is not supported as we use white for bright white
• gray is sometimes called silver - this is supported
• darkgray is sometimes called light black or bright black (both are supported)
• white is sometimes called light white or bright white (both are supported)
• we support bright and light prefixes for all colors
• we support - and _ and as separators for all colors
• we support both gray and grey spellings

From<Color> for Style is implemented by creating a style with the foreground color set to the given color. This allows you to use colors anywhere that accepts Into<Style>.

Example

use std::str::FromStr;

use ratatui_core::style::Color;

assert_eq!(Color::from_str("red"), Ok(Color::Red));
assert_eq!("red".parse(), Ok(Color::Red));
assert_eq!("lightred".parse(), Ok(Color::LightRed));
assert_eq!("light red".parse(), Ok(Color::LightRed));
assert_eq!("light-red".parse(), Ok(Color::LightRed));
assert_eq!("light_red".parse(), Ok(Color::LightRed));
assert_eq!("lightRed".parse(), Ok(Color::LightRed));
assert_eq!("bright red".parse(), Ok(Color::LightRed));
assert_eq!("bright-red".parse(), Ok(Color::LightRed));
assert_eq!("silver".parse(), Ok(Color::Gray));
assert_eq!("dark-grey".parse(), Ok(Color::DarkGray));
assert_eq!("dark gray".parse(), Ok(Color::DarkGray));
assert_eq!("light-black".parse(), Ok(Color::DarkGray));
assert_eq!("white".parse(), Ok(Color::White));
assert_eq!("bright white".parse(), Ok(Color::White));

Variants

Reset

Resets the foreground or background color

Black

ANSI Color: Black. Foreground: 30, Background: 40

Red

ANSI Color: Red. Foreground: 31, Background: 41

Green

ANSI Color: Green. Foreground: 32, Background: 42

Yellow

ANSI Color: Yellow. Foreground: 33, Background: 43

Blue

ANSI Color: Blue. Foreground: 34, Background: 44

Magenta

ANSI Color: Magenta. Foreground: 35, Background: 45

Cyan

ANSI Color: Cyan. Foreground: 36, Background: 46

Gray

ANSI Color: White. Foreground: 37, Background: 47

Note that this is sometimes called silver or white but we use white for bright white

DarkGray

ANSI Color: Bright Black. Foreground: 90, Background: 100

Note that this is sometimes called light black or bright black but we use dark gray

LightRed

ANSI Color: Bright Red. Foreground: 91, Background: 101

LightGreen

ANSI Color: Bright Green. Foreground: 92, Background: 102

LightYellow

ANSI Color: Bright Yellow. Foreground: 93, Background: 103

LightBlue

ANSI Color: Bright Blue. Foreground: 94, Background: 104

LightMagenta

ANSI Color: Bright Magenta. Foreground: 95, Background: 105

LightCyan

ANSI Color: Bright Cyan. Foreground: 96, Background: 106

White

ANSI Color: Bright White. Foreground: 97, Background: 107 Sometimes called bright white or light white in some terminals

Rgb(u8, u8, u8)

An RGB color.

Note that only terminals that support 24-bit true color will display this correctly. Notably versions of Windows Terminal prior to Windows 10 and macOS Terminal.app do not support this.

If the terminal does not support true color, code using the TermwizBackend will fallback to the default text color. Crossterm and Termion do not have this capability and the display will be unpredictable (e.g. Terminal.app may display glitched blinking text). See https://github.com/ratatui/ratatui/issues/475 for an example of this problem.

See also: https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit

Indexed(u8)

An 8-bit 256 color.

See also https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit

Implementations

impl Color

pub const fn from_u32(u: u32) -> Color

Convert a u32 to a Color

The u32 should be in the format 0x00RRGGBB.

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Color

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

Formats the value using the given formatter.

impl Default for Color

fn default() -> Color

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Color

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<Color, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

This is used to deserialize a value into Color via serde.

This implementation uses the FromStr trait to deserialize strings, so named colours, RGB, and indexed values are able to be deserialized. In addition, values that were produced by the the older serialization implementation of Color are also able to be deserialized.

Prior to v0.26.0, Ratatui would be serialized using a map for indexed and RGB values, for examples in json {"Indexed": 10} and {"Rgb": [255, 0, 255]} respectively. Now they are serialized using the string representation of the index and the RGB hex value, for example in json it would now be "10" and "#FF00FF" respectively.

See the Color documentation for more information on color names.

Examples

use std::str::FromStr;

use ratatui_core::style::Color;

#[derive(Debug, serde::Deserialize)]
struct Theme {
    color: Color,
}

let theme: Theme = serde_json::from_str(r#"{"color": "bright-white"}"#)?;
assert_eq!(theme.color, Color::White);

let theme: Theme = serde_json::from_str(r##"{"color": "#00FF00"}"##)?;
assert_eq!(theme.color, Color::Rgb(0, 255, 0));

let theme: Theme = serde_json::from_str(r#"{"color": "42"}"#)?;
assert_eq!(theme.color, Color::Indexed(42));

let err = serde_json::from_str::<Theme>(r#"{"color": "invalid"}"#).unwrap_err();
assert!(err.is_data());
assert_eq!(
    err.to_string(),
    "Failed to parse Colors at line 1 column 20"
);

// Deserializing from the previous serialization implementation
let theme: Theme = serde_json::from_str(r#"{"color": {"Rgb":[255,0,255]}}"#)?;
assert_eq!(theme.color, Color::Rgb(255, 0, 255));

let theme: Theme = serde_json::from_str(r#"{"color": {"Indexed":10}}"#)?;
assert_eq!(theme.color, Color::Indexed(10));

impl Display for Color

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

Formats the value using the given formatter.

impl From<[u8; 3]> for Color

fn from(_: [u8; 3]) -> Color

Converts an array of 3 u8 values to a Color::Rgb instance.

impl From<[u8; 4]> for Color

fn from(_: [u8; 4]) -> Color

Converts an array of 4 u8 values to a Color::Rgb instance (ignoring the alpha value).

impl From<(u8, u8, u8)> for Color

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

Converts a tuple of 3 u8 values to a Color::Rgb instance.

impl From<(u8, u8, u8, u8)> for Color

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

Converts a tuple of 4 u8 values to a Color::Rgb instance (ignoring the alpha value).

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 FromCrossterm<Color> for Color

fn from_crossterm(value: Color) -> Color

Converts the crossterm type to a ratatui type.

impl FromStr for Color

Converts a string representation to a Color instance.

The from_str function attempts to parse the given string and convert it to the corresponding Color variant. It supports named colors, RGB values, and indexed colors. If the string cannot be parsed, a ParseColorError is returned.

See the Color documentation for more information on the supported color names.

Examples

use std::str::FromStr;

use ratatui_core::style::Color;

let color: Color = Color::from_str("blue").unwrap();
assert_eq!(color, Color::Blue);

let color: Color = Color::from_str("#FF0000").unwrap();
assert_eq!(color, Color::Rgb(255, 0, 0));

let color: Color = Color::from_str("10").unwrap();
assert_eq!(color, Color::Indexed(10));

let color: Result<Color, _> = Color::from_str("invalid_color");
assert!(color.is_err());

type Err = ParseColorError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Color, <Color as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Color

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 IntoCrossterm<Color> for Color

fn into_crossterm(self) -> Color

Converts the ratatui type to a crossterm type.

impl PartialEq for Color

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

Available on crate feature serde only.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

This utilises the fmt::Display implementation for serialization.

impl Copy for Color

impl Eq for Color

impl StructuralPartialEq for Color