Struct Style 

#[non_exhaustive]
pub struct Style {
    pub foreground: Option<Color>,
    pub background: Option<Color>,
    pub bold: Option<bool>,
    pub italic: Option<bool>,
    pub underline: Option<bool>,
    pub blink: Option<bool>,
    pub invert: Option<bool>,
    pub strikethrough: Option<bool>,
}

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

Each field of this struct is an Option. When the value is None, then the particular field is unspecified. By default, this is the same as setting it to Some(Default::default()). However, two style can be merged with either Style::with (or the + operator) or Style::or. This allows another style to override certain fields only if they are unspecified.

Example

use line_ui::Style;

let style1 = Style::fg(1);
let style2 = Style::fg(2) + Style::BOLD;

assert_eq!(style1 + style2, style2);
assert_eq!(style1.with(style2), style2); // `with` is equivalent to `+`

assert_eq!(style2 + style1, Style::fg(1) + Style::BOLD);
assert_eq!(style1.or(style2), Style::fg(1) + Style::BOLD);
// `or` is equivalent to `+` with operands flipped

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

foreground: Option<Color>

The foreground color.

background: Option<Color>

The background color.

bold: Option<bool>

Whether the text should be bold.

italic: Option<bool>

Whether the text should be italicized.

underline: Option<bool>

Whether the text should be underlined.

blink: Option<bool>

Whether the text should be blinking (not widely supported).

invert: Option<bool>

Whether the text should have its colors inverted.

strikethrough: Option<bool>

Whether the text should be crossed out (not widely supported).

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 UNDERLINE: Style

Underlined text.

pub const BLINK: Style

Blinking text (not widely supported).

pub const INVERT: Style

Inverted colors.

pub const STRIKETHROUGH: Style

Crossed-out text (not widely supported).

pub fn fg(color: impl Into<Color>) -> 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<'static> {
    match player {
        None => "-".styled(Style::fg(245)),
        Some(Player::X) => "X".styled(Style::BOLD + Style::fg(33)),
        Some(Player::O) => "O".styled(Style::BOLD + Style::fg(203)),
    }
}

pub fn bg(color: impl Into<Color>) -> 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)
                    .styled(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