[][src]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 or default styling applied.

Foreground Color Constructors

Return a new Paint structure with a foreground color applied.

Getters

Return information about the Paint structure.

Setters

Set a style property on a given Paint structure.

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.

Methods

impl<T> Paint<T>
[src]

Constructs a new Paint structure encapsulating item with no set styling.

use yansi::Paint;

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

Constructs a new Paint structure encapsulating item with the active terminal's default foreground and background.

use yansi::Paint;

println!("This is going to use {}!", Paint::default("default colors"));

Constructs a new masked Paint structure encapsulating item with no set styling.

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("🌱 "));

Constructs a new wrapping Paint structure encapsulating item with default styling.

A wrapping Paint converts all color resets written out by the internal value to the styling of itself. This allows for seamless color wrapping of other colored text.

Performance

In order to wrap an internal value, the internal value must first be written out to a local buffer and examined. As a result, displaying a wrapped value is likely to result in a heap allocation and copy.

Example

use yansi::{Paint, Color};

let inner = format!("{} and {}", Paint::red("Stop"), Paint::green("Go"));

// 'Hey!' will be unstyled, "Stop" will be red, "and" will be blue, and
// "Go" will be green. Without a wrapping `Paint`, "and" would be
// unstyled.
println!("Hey! {}", Paint::wrapping(inner).fg(Color::Blue));

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!"));

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!"));

Constructs a new Paint structure encapsulating item with the foreground color set to black.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to red.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to green.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to yellow.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to blue.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to magenta.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to cyan.

use yansi::Paint; 

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

Constructs a new Paint structure encapsulating item with the foreground color set to white.

use yansi::Paint; 

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

Retrieves the style currently set on self.

use yansi::{Style, Color, Paint};

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

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

Retrieves a borrow to the inner item.

use yansi::Paint;

let x = Paint::red("Hello, world!");
assert_eq!(*x.inner(), "Hello, world!");

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, Color, Style};

let s = Style::new(Color::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!"));

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());

Makes self a wrapping Paint.

A wrapping Paint converts all color resets written out by the internal value to the styling of itself. This allows for seamless color wrapping of other colored text.

Performance

In order to wrap an internal value, the internal value must first be written out to a local buffer and examined. As a result, displaying a wrapped value is likely to result in a heap allocation and copy.

Example

use yansi::{Paint, Color};

let inner = format!("{} and {}", Paint::red("Stop"), Paint::green("Go"));

// 'Hey!' will be unstyled, "Stop" will be red, "and" will be blue, and
// "Go" will be green. Without a wrapping `Paint`, "and" would be
// unstyled.
println!("Hey! {}", Paint::blue(inner).wrap());

Sets the foreground to color.

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

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

Sets the background to color.

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

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

Enables the bold style on self .

use yansi::Paint; 

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

Enables the dimmed style on self .

use yansi::Paint; 

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

Enables the italic style on self .

use yansi::Paint; 

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

Enables the underline style on self .

use yansi::Paint; 

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

Enables the blink style on self .

use yansi::Paint; 

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

Enables the invert style on self .

use yansi::Paint; 

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

Enables the hidden style on self .

use yansi::Paint; 

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

Enables the strikethrough style on self .

use yansi::Paint; 

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

impl Paint<()>
[src]

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());

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());

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());

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: Clone> Clone for Paint<T>
[src]

Performs copy-assignment from source. Read more

impl<T: Copy> Copy for Paint<T>
[src]

impl<T: Eq> Eq for Paint<T>
[src]

impl<T: PartialOrd> PartialOrd<Paint<T>> for Paint<T>
[src]

impl<T: Default> Default for Paint<T>
[src]

impl<T: PartialEq> PartialEq<Paint<T>> for Paint<T>
[src]

impl<T: Ord> Ord for Paint<T>
[src]

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

impl<T: Display> Display for Paint<T>
[src]

impl<T: Debug> Debug for Paint<T>
[src]

impl<T: Hash> Hash for Paint<T>
[src]

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

Auto Trait Implementations

impl<T> Send for Paint<T> where
    T: Send

impl<T> Sync for Paint<T> where
    T: Sync

Blanket Implementations

impl<T> From for T
[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> BorrowMut for T where
    T: ?Sized
[src]