Struct yansi::Paint

pub struct Paint<T> { /* fields omitted */ }

A structure encapsulating an item and styling.

See the crate level documentation for usage information.

Method Glossary

The Paint structure exposes many methods for convenience.

Unstyled Constructors

Return a new Paint structure with no styling applied.

• Paint::new(item: T)
• Paint::masked(item: T)

Foreground Color Constructors

Return a new Paint structure with a foreground color applied.

• Paint::rgb(r: u8, g: u8, b: u8, item: T)
• Paint::fixed(color: u8, item: T)
• Paint::black(item: T)
• Paint::red(item: T)
• Paint::green(item: T)
• Paint::yellow(item: T)
• Paint::blue(item: T)
• Paint::purple(item: T)
• Paint::cyan(item: T)
• Paint::white(item: T)

Getters

Return information about the Paint structure.

• paint.style()

Setters

Set a style property on a given Paint structure.

• paint.with_style(style: Style)
• paint.mask()
• paint.fg(color: Color)
• paint.bg(color: Color)
• paint.bold()
• paint.dimmed()
• paint.italic()
• paint.underline()
• paint.blink()
• paint.invert()
• paint.hidden()
• paint.strikethrough()

These methods can be chained:

use yansi::Paint;

Paint::new("hi").underline().invert().italic().dimmed().bold();

Global Methods

Modify or observe the global behavior of painting.

• Paint::enable()
• Paint::disable()
• Paint::is_enabled()
• Paint::enable_windows_ascii()

Methods

impl<T> Paint<T>

pub fn new(item: T) -> Paint<T>

Constructs a new Paint structure encapsulating item with no styling.

use yansi::Paint;

assert_eq!(Paint::new("hello!").to_string(), "hello!".to_string());

pub fn masked(item: T) -> Paint<T>

Constructs a new masked Paint structure encapsulating item.

A masked Paint is not written out when painting is disabled during Display or Debug invocations. When painting is enabled, masking has no effect.

use yansi::Paint;

// The emoji won't be printed when coloring is disabled.
println!("{}Sprout!", Paint::masked("🌱 "));

pub fn rgb(r: u8, g: u8, b: u8, item: T) -> Paint<T>

Constructs a new Paint structure encapsulating item with the foreground color set to the RGB color r, g, b.

use yansi::Paint;

println!("This is going to be funky: {}", Paint::rgb(70, 130, 122, "hi!"));

pub fn fixed(color: u8, item: T) -> Paint<T>

Constructs a new Paint structure encapsulating item with the foreground color set to the fixed 256-bit color color.

use yansi::Paint;

println!("This is going to be funky: {}", Paint::fixed(100, "hi!"));

pub fn black(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to black.

use yansi::Paint; 

println!("This is going to be black: {}", Paint::black("yay!"));

pub fn red(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to red.

use yansi::Paint; 

println!("This is going to be red: {}", Paint::red("yay!"));

pub fn green(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to green.

use yansi::Paint; 

println!("This is going to be green: {}", Paint::green("yay!"));

pub fn yellow(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to yellow.

use yansi::Paint; 

println!("This is going to be yellow: {}", Paint::yellow("yay!"));

pub fn blue(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to blue.

use yansi::Paint; 

println!("This is going to be blue: {}", Paint::blue("yay!"));

pub fn purple(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to purple.

use yansi::Paint; 

println!("This is going to be purple: {}", Paint::purple("yay!"));

pub fn cyan(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to cyan.

use yansi::Paint; 

println!("This is going to be cyan: {}", Paint::cyan("yay!"));

pub fn white(item: T) -> Paint<T>

Constructs a new Paintstructure encapsulating itemwith the foreground color set to white.

use yansi::Paint; 

println!("This is going to be white: {}", Paint::white("yay!"));

pub fn style(&self) -> Style

Retrieves the style currently set on self.

use yansi::{Style, Paint};

let alert = Style::red().bold().underline();
let painted = Paint::red("hi").bold().underline();

assert_eq!(alert, painted.style());

pub fn with_style(self, style: Style) -> Paint<T>

Sets the style of self to style.

Any styling currently set on self is lost. Prefer to use the style.paint() method to create a Paint struct from Style.

use yansi::{Paint, Style};

let s = Style::red().bold().underline();

// Using this method.
println!("Alert: {}", Paint::new("This thing happened!").with_style(s));

// Using the `style.paint()` method.
println!("Alert: {}", s.paint("This thing happened!"));

pub fn mask(self) -> Paint<T>

Masks self.

A masked Paint is not written out when painting is disabled during Display or Debug invocations. When painting is enabled, masking has no effect.

use yansi::Paint;

// "Whoops! " will only print when coloring is enabled.
println!("{}Something happened.", Paint::red("Whoops! ").mask());

pub fn fg(self, color: Color) -> Paint<T>

Sets the foreground to color.

use yansi::Paint;
use yansi::Color::Red;

println!("Red foreground: {}", Paint::new("hi!").fg(Red));

pub fn bg(self, color: Color) -> Paint<T>

Sets the background to color.

use yansi::Paint;
use yansi::Color::Yellow;

println!("Yellow background: {}", Paint::new("hi!").bg(Yellow));

pub fn bold(self) -> Paint<T>

Enables the bold style on self.

use yansi::Paint; 

println!("Using bold: {}", Paint::new("hi").bold());

pub fn dimmed(self) -> Paint<T>

Enables the dimmed style on self.

use yansi::Paint; 

println!("Using dimmed: {}", Paint::new("hi").dimmed());

pub fn italic(self) -> Paint<T>

Enables the italic style on self.

use yansi::Paint; 

println!("Using italic: {}", Paint::new("hi").italic());

pub fn underline(self) -> Paint<T>

Enables the underline style on self.

use yansi::Paint; 

println!("Using underline: {}", Paint::new("hi").underline());

pub fn blink(self) -> Paint<T>

Enables the blink style on self.

use yansi::Paint; 

println!("Using blink: {}", Paint::new("hi").blink());

pub fn invert(self) -> Paint<T>

Enables the invert style on self.

use yansi::Paint; 

println!("Using invert: {}", Paint::new("hi").invert());

pub fn hidden(self) -> Paint<T>

Enables the hidden style on self.

use yansi::Paint; 

println!("Using hidden: {}", Paint::new("hi").hidden());

pub fn strikethrough(self) -> Paint<T>

Enables the strikethrough style on self.

use yansi::Paint; 

println!("Using strikethrough: {}", Paint::new("hi").strikethrough());

impl Paint<()>

pub fn disable()

Disables coloring globally.

Example

use yansi::Paint;

// With coloring enabled, ANSI color codes are emitted.
assert_ne!(Paint::green("go").to_string(), "go".to_string());

// With coloring disabled, ANSI color codes are _not_ emitted.
Paint::disable();
assert_eq!(Paint::green("go").to_string(), "go".to_string());

pub fn enable()

Enables coloring globally. Coloring is enabled by default, so this method should only be called to re enable coloring.

Example

use yansi::Paint;

// With coloring disabled, ANSI color codes are _not_ emitted.
Paint::disable();
assert_eq!(Paint::green("go").to_string(), "go".to_string());

// Reenabling causes color code to be emitted.
Paint::enable();
assert_ne!(Paint::green("go").to_string(), "go".to_string());

pub fn is_enabled() -> bool

Returns true if coloring is enabled and false otherwise. Coloring is enabled by default but can be enabled and disabled on-the-fly with the Paint::enable() and Paint::disable() methods.

Example

use yansi::Paint;

// Coloring is enabled by default.
assert!(Paint::is_enabled());

// Disable it with `Paint::disable()`.
Paint::disable();
assert!(!Paint::is_enabled());

// Reenable with `Paint::enable()`.
Paint::enable();
assert!(Paint::is_enabled());

pub fn enable_windows_ascii() -> bool

Enables ASCII terminal escape sequences on Windows consoles when possible. Returns true if escape sequence support was successfully enabled and false otherwise. On non-Windows targets, this method always returns true.

Support for escape sequences in Windows consoles was added in the Windows 10 anniversary update. For targets with older Windows installations, this method is expected to return false.

Example

use yansi::Paint;

// A best-effort Windows ASCII terminal support enabling.
Paint::enable_windows_ascii();

Trait Implementations

impl<T: Default> Default for Paint<T>

fn default() -> Paint<T>

Returns the "default value" for a type.

impl<T: Eq> Eq for Paint<T>

impl<T: PartialEq> PartialEq for Paint<T>

fn eq(&self, __arg_0: &Paint<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Paint<T>) -> bool

This method tests for !=.

impl<T: Ord> Ord for Paint<T>

fn cmp(&self, __arg_0: &Paint<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<T: PartialOrd> PartialOrd for Paint<T>

fn partial_cmp(&self, __arg_0: &Paint<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &Paint<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &Paint<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &Paint<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &Paint<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Hash> Hash for Paint<T>

fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Copy> Copy for Paint<T>

impl<T: Clone> Clone for Paint<T>

fn clone(&self) -> Paint<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Display> Display for Paint<T>

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

Formats the value using the given formatter.

impl<T: Debug> Debug for Paint<T>

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

Formats the value using the given formatter.