Trait colorz::Colorize

pub trait Colorize {
    // Provided methods
    fn into_style(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn style(&self) -> StyledValue<&Self> { ... }
    fn into_style_with<F, B, U>(
        self,
        style: Style<F, B, U>
    ) -> StyledValue<Self, F, B, U>
       where Self: Sized { ... }
    fn style_with<F, B, U>(
        &self,
        style: Style<F, B, U>
    ) -> StyledValue<&Self, F, B, U> { ... }
    fn fg<C>(&self, color: C) -> StyledValue<&Self, C> { ... }
    fn into_fg<C>(self, color: C) -> StyledValue<Self, C>
       where Self: Sized { ... }
    fn bg<C>(&self, color: C) -> StyledValue<&Self, NoColor, C> { ... }
    fn into_bg<C>(self, color: C) -> StyledValue<Self, NoColor, C>
       where Self: Sized { ... }
    fn underline_color<C>(
        &self,
        color: C
    ) -> StyledValue<&Self, NoColor, NoColor, C> { ... }
    fn into_underline_color<C>(
        self,
        color: C
    ) -> StyledValue<Self, NoColor, NoColor, C>
       where Self: Sized { ... }
    fn black(&self) -> StyledValue<&Self, Black> { ... }
    fn red(&self) -> StyledValue<&Self, Red> { ... }
    fn green(&self) -> StyledValue<&Self, Green> { ... }
    fn yellow(&self) -> StyledValue<&Self, Yellow> { ... }
    fn blue(&self) -> StyledValue<&Self, Blue> { ... }
    fn magenta(&self) -> StyledValue<&Self, Magenta> { ... }
    fn cyan(&self) -> StyledValue<&Self, Cyan> { ... }
    fn white(&self) -> StyledValue<&Self, White> { ... }
    fn bright_black(&self) -> StyledValue<&Self, BrightBlack> { ... }
    fn bright_red(&self) -> StyledValue<&Self, BrightRed> { ... }
    fn bright_green(&self) -> StyledValue<&Self, BrightGreen> { ... }
    fn bright_yellow(&self) -> StyledValue<&Self, BrightYellow> { ... }
    fn bright_blue(&self) -> StyledValue<&Self, BrightBlue> { ... }
    fn bright_magenta(&self) -> StyledValue<&Self, BrightMagenta> { ... }
    fn bright_cyan(&self) -> StyledValue<&Self, BrightCyan> { ... }
    fn bright_white(&self) -> StyledValue<&Self, BrightWhite> { ... }
    fn on_black(&self) -> StyledValue<&Self, NoColor, Black> { ... }
    fn on_red(&self) -> StyledValue<&Self, NoColor, Red> { ... }
    fn on_green(&self) -> StyledValue<&Self, NoColor, Green> { ... }
    fn on_yellow(&self) -> StyledValue<&Self, NoColor, Yellow> { ... }
    fn on_blue(&self) -> StyledValue<&Self, NoColor, Blue> { ... }
    fn on_magenta(&self) -> StyledValue<&Self, NoColor, Magenta> { ... }
    fn on_cyan(&self) -> StyledValue<&Self, NoColor, Cyan> { ... }
    fn on_white(&self) -> StyledValue<&Self, NoColor, White> { ... }
    fn on_bright_black(&self) -> StyledValue<&Self, NoColor, BrightBlack> { ... }
    fn on_bright_red(&self) -> StyledValue<&Self, NoColor, BrightRed> { ... }
    fn on_bright_green(&self) -> StyledValue<&Self, NoColor, BrightGreen> { ... }
    fn on_bright_yellow(&self) -> StyledValue<&Self, NoColor, BrightYellow> { ... }
    fn on_bright_blue(&self) -> StyledValue<&Self, NoColor, BrightBlue> { ... }
    fn on_bright_magenta(&self) -> StyledValue<&Self, NoColor, BrightMagenta> { ... }
    fn on_bright_cyan(&self) -> StyledValue<&Self, NoColor, BrightCyan> { ... }
    fn on_bright_white(&self) -> StyledValue<&Self, NoColor, BrightWhite> { ... }
    fn into_black(self) -> StyledValue<Self, Black>
       where Self: Sized { ... }
    fn into_red(self) -> StyledValue<Self, Red>
       where Self: Sized { ... }
    fn into_green(self) -> StyledValue<Self, Green>
       where Self: Sized { ... }
    fn into_yellow(self) -> StyledValue<Self, Yellow>
       where Self: Sized { ... }
    fn into_blue(self) -> StyledValue<Self, Blue>
       where Self: Sized { ... }
    fn into_magenta(self) -> StyledValue<Self, Magenta>
       where Self: Sized { ... }
    fn into_cyan(self) -> StyledValue<Self, Cyan>
       where Self: Sized { ... }
    fn into_white(self) -> StyledValue<Self, White>
       where Self: Sized { ... }
    fn into_bright_black(self) -> StyledValue<Self, BrightBlack>
       where Self: Sized { ... }
    fn into_bright_red(self) -> StyledValue<Self, BrightRed>
       where Self: Sized { ... }
    fn into_bright_green(self) -> StyledValue<Self, BrightGreen>
       where Self: Sized { ... }
    fn into_bright_yellow(self) -> StyledValue<Self, BrightYellow>
       where Self: Sized { ... }
    fn into_bright_blue(self) -> StyledValue<Self, BrightBlue>
       where Self: Sized { ... }
    fn into_bright_magenta(self) -> StyledValue<Self, BrightMagenta>
       where Self: Sized { ... }
    fn into_bright_cyan(self) -> StyledValue<Self, BrightCyan>
       where Self: Sized { ... }
    fn into_bright_white(self) -> StyledValue<Self, BrightWhite>
       where Self: Sized { ... }
    fn into_on_black(self) -> StyledValue<Self, NoColor, Black>
       where Self: Sized { ... }
    fn into_on_red(self) -> StyledValue<Self, NoColor, Red>
       where Self: Sized { ... }
    fn into_on_green(self) -> StyledValue<Self, NoColor, Green>
       where Self: Sized { ... }
    fn into_on_yellow(self) -> StyledValue<Self, NoColor, Yellow>
       where Self: Sized { ... }
    fn into_on_blue(self) -> StyledValue<Self, NoColor, Blue>
       where Self: Sized { ... }
    fn into_on_magenta(self) -> StyledValue<Self, NoColor, Magenta>
       where Self: Sized { ... }
    fn into_on_cyan(self) -> StyledValue<Self, NoColor, Cyan>
       where Self: Sized { ... }
    fn into_on_white(self) -> StyledValue<Self, NoColor, White>
       where Self: Sized { ... }
    fn into_on_bright_black(self) -> StyledValue<Self, NoColor, BrightBlack>
       where Self: Sized { ... }
    fn into_on_bright_red(self) -> StyledValue<Self, NoColor, BrightRed>
       where Self: Sized { ... }
    fn into_on_bright_green(self) -> StyledValue<Self, NoColor, BrightGreen>
       where Self: Sized { ... }
    fn into_on_bright_yellow(self) -> StyledValue<Self, NoColor, BrightYellow>
       where Self: Sized { ... }
    fn into_on_bright_blue(self) -> StyledValue<Self, NoColor, BrightBlue>
       where Self: Sized { ... }
    fn into_on_bright_magenta(self) -> StyledValue<Self, NoColor, BrightMagenta>
       where Self: Sized { ... }
    fn into_on_bright_cyan(self) -> StyledValue<Self, NoColor, BrightCyan>
       where Self: Sized { ... }
    fn into_on_bright_white(self) -> StyledValue<Self, NoColor, BrightWhite>
       where Self: Sized { ... }
    fn bold(&self) -> StyledValue<&Self> { ... }
    fn dimmed(&self) -> StyledValue<&Self> { ... }
    fn italics(&self) -> StyledValue<&Self> { ... }
    fn underline(&self) -> StyledValue<&Self> { ... }
    fn double_underline(&self) -> StyledValue<&Self> { ... }
    fn blink(&self) -> StyledValue<&Self> { ... }
    fn blink_fast(&self) -> StyledValue<&Self> { ... }
    fn reverse(&self) -> StyledValue<&Self> { ... }
    fn hide(&self) -> StyledValue<&Self> { ... }
    fn strikethrough(&self) -> StyledValue<&Self> { ... }
    fn overline(&self) -> StyledValue<&Self> { ... }
    fn superscript(&self) -> StyledValue<&Self> { ... }
    fn subscript(&self) -> StyledValue<&Self> { ... }
    fn into_bold(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_dimmed(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_italics(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_underline(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_double_underline(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_blink(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_blink_fast(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_reverse(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_hide(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_strikethrough(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_overline(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_superscript(self) -> StyledValue<Self>
       where Self: Sized { ... }
    fn into_subscript(self) -> StyledValue<Self>
       where Self: Sized { ... }
}

An extension trait for all values which adds convenience formatting functions

Provided Methods

fn into_style(self) -> StyledValue<Self>where Self: Sized,

Convert a value to a StyledValue

fn style(&self) -> StyledValue<&Self>

Convert a value to a StyledValue

fn into_style_with<F, B, U>( self, style: Style<F, B, U> ) -> StyledValue<Self, F, B, U>where Self: Sized,

Convert a value to a StyledValue and applies the given style

fn style_with<F, B, U>( &self, style: Style<F, B, U> ) -> StyledValue<&Self, F, B, U>

Convert a value to a StyledValue and applies the given style

fn fg<C>(&self, color: C) -> StyledValue<&Self, C>

Changes the foreground color

Examples found in repository

examples/all_xterm_colors.rs (line 6)

fn main() {
    for i in 0..=255 {
        let color = XtermColor::from(i);
        println!("{:?}", color.fg(color));
    }
}

examples/dyn_colors.rs (line 9)

fn main() {
    let mut color = AnsiColor::Red;
    println!("{}", "red".fg(color));

    color = AnsiColor::Blue;
    println!("{}", "blue".fg(color));

    let color = XtermColor::Fuchsia;
    println!("{}", "fuchsia".fg(color));

    let color = RgbColor {
        red: 141,
        green: 59,
        blue: 212,
    };
    println!("{}", "custom purple".fg(color));

    let color = match random_number() {
        1 => Color::Rgb(colorz::rgb::RgbColor {
            red: 141,
            green: 59,
            blue: 212,
        }),
        2 => Color::Ansi(AnsiColor::BrightGreen),
        3 => "#F3F3F3".parse().unwrap(),
        _ => Color::Xterm(XtermColor::Aqua),
    };

    println!("{}", "mystery color".fg(color));
}

examples/colors.rs (line 11)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn into_fg<C>(self, color: C) -> StyledValue<Self, C>where Self: Sized,

Changes the foreground color

fn bg<C>(&self, color: C) -> StyledValue<&Self, NoColor, C>

Changes the background color

fn into_bg<C>(self, color: C) -> StyledValue<Self, NoColor, C>where Self: Sized,

Changes the background color

fn underline_color<C>( &self, color: C ) -> StyledValue<&Self, NoColor, NoColor, C>

Changes the underline color

fn into_underline_color<C>( self, color: C ) -> StyledValue<Self, NoColor, NoColor, C>where Self: Sized,

Changes the underline color

fn black(&self) -> StyledValue<&Self, Black>

Changes the foreground to black

Examples found in repository

examples/colors.rs (line 8)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn red(&self) -> StyledValue<&Self, Red>

Changes the foreground to red

Examples found in repository

examples/basic.rs (line 4)

fn main() {
    println!("Wow this {} {}", "is so red".red(), "and green".on_green());
}

examples/colors.rs (line 37)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn green(&self) -> StyledValue<&Self, Green>

Changes the foreground to green

Examples found in repository

examples/colors.rs (line 5)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn yellow(&self) -> StyledValue<&Self, Yellow>

Changes the foreground to yellow

Examples found in repository

examples/colors.rs (line 6)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn blue(&self) -> StyledValue<&Self, Blue>

Changes the foreground to blue

Examples found in repository

examples/colors.rs (line 7)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

examples/mode.rs (line 34)

fn main() {
    // NOTE: this example uses `stream(Stderr)` even though it's writing
    // to stdout to make it easier to see how `mode::Mode::Detect` works
    // try running this command wihtout redirecting stderr and while
    // redirecting stderr to `/dev/null` (or some file) to see how it
    // colors things differently
    //
    // ```
    // cargo run --example mode
    // cargo run --example mode 2> /dev/null
    //
    // cargo run --example mode --features strip-colors
    // cargo run --example mode --features strip-colors 2> /dev/null
    // ```
    //
    // NOTE: that colorz currently uses `std::io::IsTerminal` to detect
    // if stdin/stderr/stdout have been redirected

    assert_eq!(mode::get_default_stream(), AlwaysColor);

    mode::set_default_stream(Stderr);

    assert_eq!(mode::get_default_stream(), Stderr);

    #[cfg(feature = "std")]
    {
        mode::set_coloring_mode_from_env();
        println!("{}", "blue stderr".blue());
        println!("{}", "blue stdout".blue().stream(Stdout));
        println!("{}", "blue always".blue().stream(AlwaysColor));
        println!("{}", "blue never".blue().stream(NeverColor));
    }

    println!("color mode=always");
    mode::set_coloring_mode(mode::Mode::Always);
    println!("{}", "blue stderr".blue());
    println!("{}", "blue stdout".blue().stream(Stdout));
    println!("{}", "blue always".blue().stream(AlwaysColor));
    println!("{}", "blue never".blue().stream(NeverColor));

    println!("color mode=detect");
    mode::set_coloring_mode(mode::Mode::Detect);
    println!("{}", "blue stderr".blue());
    println!("{}", "blue stdout".blue().stream(Stdout));
    println!("{}", "blue always".blue().stream(AlwaysColor));
    println!("{}", "blue never".blue().stream(NeverColor));

    println!("color mode=never");
    mode::set_coloring_mode(mode::Mode::Never);
    println!("{}", "blue stderr".blue());
    println!("{}", "blue stdout".blue().stream(Stdout));
    println!("{}", "blue always".blue().stream(AlwaysColor));
    println!("{}", "blue never".blue().stream(NeverColor));
}

fn magenta(&self) -> StyledValue<&Self, Magenta>

Changes the foreground to magenta

fn cyan(&self) -> StyledValue<&Self, Cyan>

Changes the foreground to cyan

fn white(&self) -> StyledValue<&Self, White>

Changes the foreground to white

fn bright_black(&self) -> StyledValue<&Self, BrightBlack>

Changes the foreground to bright black

fn bright_red(&self) -> StyledValue<&Self, BrightRed>

Changes the foreground to bright red

fn bright_green(&self) -> StyledValue<&Self, BrightGreen>

Changes the foreground to bright green

fn bright_yellow(&self) -> StyledValue<&Self, BrightYellow>

Changes the foreground to bright yellow

fn bright_blue(&self) -> StyledValue<&Self, BrightBlue>

Changes the foreground to bright blue

fn bright_magenta(&self) -> StyledValue<&Self, BrightMagenta>

Changes the foreground to bright magenta

fn bright_cyan(&self) -> StyledValue<&Self, BrightCyan>

Changes the foreground to bright cyan

fn bright_white(&self) -> StyledValue<&Self, BrightWhite>

Changes the foreground to bright white

fn on_black(&self) -> StyledValue<&Self, NoColor, Black>

Changes the background to black

fn on_red(&self) -> StyledValue<&Self, NoColor, Red>

Changes the background to red

fn on_green(&self) -> StyledValue<&Self, NoColor, Green>

Changes the background to green

Examples found in repository

examples/basic.rs (line 4)

fn main() {
    println!("Wow this {} {}", "is so red".red(), "and green".on_green());
}

fn on_yellow(&self) -> StyledValue<&Self, NoColor, Yellow>

Changes the background to yellow

fn on_blue(&self) -> StyledValue<&Self, NoColor, Blue>

Changes the background to blue

fn on_magenta(&self) -> StyledValue<&Self, NoColor, Magenta>

Changes the background to magenta

fn on_cyan(&self) -> StyledValue<&Self, NoColor, Cyan>

Changes the background to cyan

fn on_white(&self) -> StyledValue<&Self, NoColor, White>

Changes the background to white

fn on_bright_black(&self) -> StyledValue<&Self, NoColor, BrightBlack>

Changes the background to bright black

fn on_bright_red(&self) -> StyledValue<&Self, NoColor, BrightRed>

Changes the background to bright red

fn on_bright_green(&self) -> StyledValue<&Self, NoColor, BrightGreen>

Changes the background to bright green

fn on_bright_yellow(&self) -> StyledValue<&Self, NoColor, BrightYellow>

Changes the background to bright yellow

fn on_bright_blue(&self) -> StyledValue<&Self, NoColor, BrightBlue>

Changes the background to bright blue

fn on_bright_magenta(&self) -> StyledValue<&Self, NoColor, BrightMagenta>

Changes the background to bright magenta

fn on_bright_cyan(&self) -> StyledValue<&Self, NoColor, BrightCyan>

Changes the background to bright cyan

fn on_bright_white(&self) -> StyledValue<&Self, NoColor, BrightWhite>

Changes the background to bright white

fn into_black(self) -> StyledValue<Self, Black>where Self: Sized,

Changes the foreground to black

fn into_red(self) -> StyledValue<Self, Red>where Self: Sized,

Changes the foreground to red

fn into_green(self) -> StyledValue<Self, Green>where Self: Sized,

Changes the foreground to green

fn into_yellow(self) -> StyledValue<Self, Yellow>where Self: Sized,

Changes the foreground to yellow

fn into_blue(self) -> StyledValue<Self, Blue>where Self: Sized,

Changes the foreground to blue

fn into_magenta(self) -> StyledValue<Self, Magenta>where Self: Sized,

Changes the foreground to magenta

fn into_cyan(self) -> StyledValue<Self, Cyan>where Self: Sized,

Changes the foreground to cyan

fn into_white(self) -> StyledValue<Self, White>where Self: Sized,

Changes the foreground to white

fn into_bright_black(self) -> StyledValue<Self, BrightBlack>where Self: Sized,

Changes the foreground to bright black

fn into_bright_red(self) -> StyledValue<Self, BrightRed>where Self: Sized,

Changes the foreground to bright red

fn into_bright_green(self) -> StyledValue<Self, BrightGreen>where Self: Sized,

Changes the foreground to bright green

fn into_bright_yellow(self) -> StyledValue<Self, BrightYellow>where Self: Sized,

Changes the foreground to bright yellow

fn into_bright_blue(self) -> StyledValue<Self, BrightBlue>where Self: Sized,

Changes the foreground to bright blue

fn into_bright_magenta(self) -> StyledValue<Self, BrightMagenta>where Self: Sized,

Changes the foreground to bright magenta

fn into_bright_cyan(self) -> StyledValue<Self, BrightCyan>where Self: Sized,

Changes the foreground to bright cyan

fn into_bright_white(self) -> StyledValue<Self, BrightWhite>where Self: Sized,

Changes the foreground to bright white

fn into_on_black(self) -> StyledValue<Self, NoColor, Black>where Self: Sized,

Changes the background to black

fn into_on_red(self) -> StyledValue<Self, NoColor, Red>where Self: Sized,

Changes the background to red

fn into_on_green(self) -> StyledValue<Self, NoColor, Green>where Self: Sized,

Changes the background to green

fn into_on_yellow(self) -> StyledValue<Self, NoColor, Yellow>where Self: Sized,

Changes the background to yellow

fn into_on_blue(self) -> StyledValue<Self, NoColor, Blue>where Self: Sized,

Changes the background to blue

fn into_on_magenta(self) -> StyledValue<Self, NoColor, Magenta>where Self: Sized,

Changes the background to magenta

fn into_on_cyan(self) -> StyledValue<Self, NoColor, Cyan>where Self: Sized,

Changes the background to cyan

fn into_on_white(self) -> StyledValue<Self, NoColor, White>where Self: Sized,

Changes the background to white

fn into_on_bright_black(self) -> StyledValue<Self, NoColor, BrightBlack>where Self: Sized,

Changes the background to bright black

fn into_on_bright_red(self) -> StyledValue<Self, NoColor, BrightRed>where Self: Sized,

Changes the background to bright red

fn into_on_bright_green(self) -> StyledValue<Self, NoColor, BrightGreen>where Self: Sized,

Changes the background to bright green

fn into_on_bright_yellow(self) -> StyledValue<Self, NoColor, BrightYellow>where Self: Sized,

Changes the background to bright yellow

fn into_on_bright_blue(self) -> StyledValue<Self, NoColor, BrightBlue>where Self: Sized,

Changes the background to bright blue

fn into_on_bright_magenta(self) -> StyledValue<Self, NoColor, BrightMagenta>where Self: Sized,

Changes the background to bright magenta

fn into_on_bright_cyan(self) -> StyledValue<Self, NoColor, BrightCyan>where Self: Sized,

Changes the background to bright cyan

fn into_on_bright_white(self) -> StyledValue<Self, NoColor, BrightWhite>where Self: Sized,

Changes the background to bright white

fn bold(&self) -> StyledValue<&Self>

Applies the bold effect

Examples found in repository

examples/colors.rs (line 28)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn dimmed(&self) -> StyledValue<&Self>

Applies the dimmed effect

fn italics(&self) -> StyledValue<&Self>

Applies the italics effect

Examples found in repository

examples/colors.rs (line 29)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn underline(&self) -> StyledValue<&Self>

Applies the underline effect

Examples found in repository

examples/colors.rs (line 27)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn double_underline(&self) -> StyledValue<&Self>

Applies the double underline effect

fn blink(&self) -> StyledValue<&Self>

Applies the blink effect

Examples found in repository

examples/colors.rs (line 33)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn blink_fast(&self) -> StyledValue<&Self>

Applies the blink fast effect

Examples found in repository

examples/colors.rs (line 34)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn reverse(&self) -> StyledValue<&Self>

Applies the reverse effect

Examples found in repository

examples/colors.rs (line 31)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn hide(&self) -> StyledValue<&Self>

Applies the hide effect

Examples found in repository

examples/colors.rs (line 32)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn strikethrough(&self) -> StyledValue<&Self>

Applies the strikethrough effect

Examples found in repository

examples/colors.rs (line 30)

fn main() {
    // normal usage
    println!("{}", "green".green());
    println!("{}", "yellow".yellow());
    println!("{}", "blue".blue());
    println!("{}", "black".black());

    // generic examples
    println!("{}", "red".fg(Red));
    println!("{}", "magenta".fg(Magenta));
    println!("{}", "white".fg(White));
    println!("{}", "cyan".fg(Cyan));

    println!("\nBrights\n-------");
    println!("{}", "green".fg(BrightGreen));
    println!("{}", "yellow".fg(BrightYellow));
    println!("{}", "blue".fg(BrightBlue));
    println!("{}", "black".fg(BrightBlack));
    println!("{}", "red".fg(BrightRed));
    println!("{}", "magenta".fg(BrightMagenta));
    println!("{}", "white".fg(BrightWhite));
    println!("{}", "cyan".fg(BrightCyan));

    println!("\nStyles\n-------");
    println!("{}", "underline".underline());
    println!("{}", "bold".bold());
    println!("{}", "italic".italics());
    println!("{}", "strikethrough".strikethrough());
    println!("{}", "reverse".reverse());
    println!("1{}3", "2".hide());
    println!("{}", "blink".blink());
    println!("{}", "blink fast".blink_fast());

    // foreground and background
    let red_on_white = "red on white".red().on_white();
    println!("{}", red_on_white);
}

fn overline(&self) -> StyledValue<&Self>

Applies the overline effect

fn superscript(&self) -> StyledValue<&Self>

Applies the superscript effect

fn subscript(&self) -> StyledValue<&Self>

Applies the subscript effect

fn into_bold(self) -> StyledValue<Self>where Self: Sized,

Applies the bold effect

fn into_dimmed(self) -> StyledValue<Self>where Self: Sized,

Applies the dimmed effect

fn into_italics(self) -> StyledValue<Self>where Self: Sized,

Applies the italics effect

fn into_underline(self) -> StyledValue<Self>where Self: Sized,

Applies the underline effect

fn into_double_underline(self) -> StyledValue<Self>where Self: Sized,

Applies the double underline effect

fn into_blink(self) -> StyledValue<Self>where Self: Sized,

Applies the blink effect

fn into_blink_fast(self) -> StyledValue<Self>where Self: Sized,

Applies the blink fast effect

fn into_reverse(self) -> StyledValue<Self>where Self: Sized,

Applies the reverse effect

fn into_hide(self) -> StyledValue<Self>where Self: Sized,

Applies the hide effect

fn into_strikethrough(self) -> StyledValue<Self>where Self: Sized,

Applies the strikethrough effect

fn into_overline(self) -> StyledValue<Self>where Self: Sized,

Applies the overline effect

fn into_superscript(self) -> StyledValue<Self>where Self: Sized,

Applies the superscript effect

fn into_subscript(self) -> StyledValue<Self>where Self: Sized,

Applies the subscript effect

Implementors

impl<T: ?Sized> Colorize for T