Struct Palette 

pub struct Palette {

    pub name: Cow<'static, str>,
    pub text_light: Color,
    pub text_bright: Color,
    pub text_dark: Color,
    pub text_black: Color,
    pub white: [Color; 8],
    pub black: [Color; 8],
    pub gray: [Color; 8],
    pub red: [Color; 8],
    pub orange: [Color; 8],
    pub yellow: [Color; 8],
    pub limegreen: [Color; 8],
    pub green: [Color; 8],
    pub bluegreen: [Color; 8],
    pub cyan: [Color; 8],
    pub blue: [Color; 8],
    pub deepblue: [Color; 8],
    pub purple: [Color; 8],
    pub magenta: [Color; 8],
    pub redpink: [Color; 8],
    pub primary: [Color; 8],
    pub secondary: [Color; 8],
}

Color palette.

This provides the palette used for a theme.

The ideas packed in here are

• provide two colors for highlighting and accents.
• I always want some white, black and gray.
• I don’t want to miss out anything, so go once round the hue in HSV. Take steps of 30° then we hit pretty much anything interesting.
• Just one variant of each color is not enough, make it 4.
• Background colors need extra considerations. Extend to 8.

Fields

name: Cow<'static, str>

text_light: Color

text_bright: Color

text_dark: Color

text_black: Color

white: [Color; 8]

black: [Color; 8]

gray: [Color; 8]

red: [Color; 8]

orange: [Color; 8]

yellow: [Color; 8]

limegreen: [Color; 8]

green: [Color; 8]

bluegreen: [Color; 8]

cyan: [Color; 8]

blue: [Color; 8]

deepblue: [Color; 8]

purple: [Color; 8]

magenta: [Color; 8]

redpink: [Color; 8]

primary: [Color; 8]

secondary: [Color; 8]

Implementations

impl Palette

pub const BRIGHT_0: usize = 0usize

Color index for a bright variant of the base color. Brightness increases with the number.

pub const BRIGHT_1: usize = 1usize

Color index for a bright variant of the base color. Brightness increases with the number.

pub const BRIGHT_2: usize = 2usize

Color index for a bright variant of the base color. Brightness increases with the number.

pub const BRIGHT_3: usize = 3usize

Color index for a bright variant of the base color. Brightness increases with the number.

pub const DARK_0: usize = 4usize

Color index for a dark variant of the base color. Brightness increases with the number.

pub const DARK_1: usize = 5usize

Color index for a dark variant of the base color. Brightness increases with the number.

pub const DARK_2: usize = 6usize

Color index for a dark variant of the base color. Brightness increases with the number.

pub const DARK_3: usize = 7usize

Color index for a dark variant of the base color. Brightness increases with the number.

pub fn white(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given white shade. n is 0..=3

pub fn black(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given black shade. n is 0..=3

pub fn gray(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given gray shade. n is 0..=3

pub fn red(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given red shade. n is 0..=3

pub fn orange(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given orange shade. n is 0..=3

pub fn yellow(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given yellow shade. n is 0..=3

pub fn limegreen(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given limegreen shade. n is 0..=3

pub fn green(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given green shade. n is 0..=3

pub fn bluegreen(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given bluegreen shade. n is 0..=3

pub fn cyan(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given cyan shade. n is 0..=3

pub fn blue(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given blue shade. n is 0..=3

pub fn deepblue(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given deepblue shade. n is 0..=3

pub fn purple(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given purple shade. n is 0..=3

pub fn magenta(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given magenta shade. n is 0..=3

pub fn redpink(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given redpink shade. n is 0..=3

pub fn primary(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given primary shade. n is 0..=3

pub fn secondary(&self, n: usize, contrast: Contrast) -> Style

Create a style from the given secondary shade. n is 0..=3

impl Palette

pub fn style(&self, color: Color, contrast: Contrast) -> Style

Create a style with the given background color and contrast.

pub fn high_contrast(&self, color: Color) -> Style

Create a style with the given background color. Uses white[3] or black[0] for the foreground, based on rate_text_color.

pub fn normal_contrast(&self, color: Color) -> Style

Create a style with the given background color. Uses white[0] or black[3] for the foreground, based on rate_text_color.

pub fn normal_contrast_color(&self, bg: Color, text_colors: &[Color]) -> Style

Pick a color from the choice with a good contrast to the given background.

pub fn high_contrast_color(&self, bg: Color, text_colors: &[Color]) -> Style

Pick a color from the choice with the best contrast to the given background.

pub fn rate_text_color(color: Color) -> Option<TextColorRating>

This gives back a TextColorRating for the given background.

This converts RGB to grayscale and takes the grayscale value of VGA cyan as threshold, which is about 105 out of 255. This point is a bit arbitrary, just based on what I perceive as acceptable. But it produces a good reading contrast in my experience.

For the named colors it takes the VGA equivalent as a base. For indexed colors it splits the range in half as an estimate.

pub const fn darken(color: Color, scale_to: u8) -> Color

Reduces the range of the given color from 0..255 to 0..scale_to.

This gives a true dark equivalent which can be used as a background for a dark theme.

pub const fn grayscale(color: Color) -> Color

Converts the given color to an equivalent grayscale.

pub const fn color32(c0: u32) -> Color

Color from u32

pub const fn interpolate(c0: u32, c1: u32, dark_scale_to: u8) -> [Color; 8]

Calculates a linear interpolation for the two colors and fills the first 4 colors with it. The next 4 colors are scaled down versions using dark_scale_to.

pub const fn scale_to(v: u8, scale_to: u8) -> u8

Scale the u8 down to scale_to.

pub const fn color2rgb(color: Color) -> (u8, u8, u8)

Gives back the rgb for any ratatui Color. Has the indexed and the named colors too.

Trait Implementations

impl Clone for Palette

fn clone(&self) -> Palette

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Palette

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

Formats the value using the given formatter.

impl Default for Palette

fn default() -> Palette

Returns the “default value” for a type.

impl PartialEq for Palette

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

impl StructuralPartialEq for Palette