Struct Style 

pub struct Style {
    pub foreground: Option<u8>,
    pub background: Option<u8>,
    pub bold: Option<bool>,
    pub italic: Option<bool>,
    pub invert: Option<bool>,
}

A text style, encompassing the color and other style options.

Fields

foreground: Option<u8>

The foreground color.

background: Option<u8>

The background color.

bold: Option<bool>

Whether the text should be bold.

italic: Option<bool>

Whether the text should be italicized.

invert: Option<bool>

Whether the text should have its colors inverted.

Implementations

impl Style

pub const EMPTY: Style

The empty style, with nothing specified. Equivalent to Style::default().

pub const BOLD: Style

Bold text.

pub const ITALIC: Style

Italicized text.

pub const INVERT: Style

Inverted colors.

pub fn fg(value: u8) -> Style

Creates a style with only the foreground specified.

Examples found in repository

examples/tic_tac_toe.rs (line 136)

fn render_player(player: Option<Player>) -> impl Element {
    match player {
        None => "-".with_style(Style::fg(245)),
        Some(Player::X) => "X".with_style(Style::BOLD + Style::fg(33)),
        Some(Player::O) => "O".with_style(Style::BOLD + Style::fg(203)),
    }
}

pub fn bg(value: u8) -> Style

Creates a style with only the background specified.

Examples found in repository

examples/input.rs (line 27)

fn main() -> std::io::Result<()> {
    let stdout = std::io::stdout().into_raw_mode()?;
    let mut r = Renderer::new(stdout);

    let mut name = String::new();

    let mut events = std::io::stdin().events();
    loop {
        r.reset()?
            .render((
                "Enter your name: ".into_element(),
                (name.into_element(), Cursor, Gap(1))
                    .fixed_width(20)
                    .truncated(Direction::Left)
                    .with_style(Style::bg(240)),
            ))?
            .finish()?;

        let Some(event) = events.next().transpose()? else {
            break;
        };
        match event {
            Event::Key(Key::Char(ch)) if !ch.is_ascii_control() => name.push(ch),
            Event::Key(Key::Char('\n' | '\r')) => break,
            Event::Key(Key::Backspace) => {
                name.pop();
            }
            _ => {}
        }
    }

    r.clear()?;
    drop(r);
    println!("Your name is {name:?}");
    Ok(())
}

pub fn with(self, other: Style) -> Style

Merges two styles, with other taking precedence.

pub fn or(self, other: Style) -> Style

Merges two styles, with self taking precedence.

Trait Implementations

impl Add for Style

type Output = Style

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign for Style

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Self

Returns the “default value” for a type.

impl Display for Style

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

Formats the value using the given formatter.

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