pub struct Paint<T> { /* private fields */ }
Expand description
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.
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::magenta(item: T)
Paint::cyan(item: T)
Paint::white(item: T)
Getters
Return information about the Paint
structure.
Setters
Set a style property on a given Paint
structure.
paint.with_style(style: Style)
paint.mask()
paint.wrap()
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.
Implementations§
source§impl<T> Paint<T>
impl<T> Paint<T>
sourcepub fn new(item: T) -> Paint<T>
pub fn new(item: T) -> Paint<T>
Constructs a new Paint
structure encapsulating item
with no set
styling.
use yansi::Paint;
assert_eq!(Paint::new("hello!").to_string(), "hello!".to_string());
sourcepub fn default(item: T) -> Paint<T>
pub fn default(item: T) -> Paint<T>
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"));
sourcepub fn masked(item: T) -> Paint<T>
pub fn masked(item: T) -> Paint<T>
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("🌱 "));
sourcepub fn wrapping(item: T) -> Paint<T>
pub fn wrapping(item: T) -> Paint<T>
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));
sourcepub fn rgb(r: u8, g: u8, b: u8, item: T) -> Paint<T>
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!"));
sourcepub fn fixed(color: u8, item: T) -> Paint<T>
pub fn fixed(color: u8, item: T) -> Paint<T>
Constructs a new Paint
structure encapsulating item
with the
foreground color set to the fixed 8-bit color color
.
use yansi::Paint;
println!("This is going to be funky: {}", Paint::fixed(100, "hi!"));
sourcepub fn black(item: T) -> Paint<T>
pub fn black(item: T) -> Paint<T>
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!"));
sourcepub fn red(item: T) -> Paint<T>
pub fn red(item: T) -> Paint<T>
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!"));
sourcepub fn green(item: T) -> Paint<T>
pub fn green(item: T) -> Paint<T>
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!"));
sourcepub fn yellow(item: T) -> Paint<T>
pub fn yellow(item: T) -> Paint<T>
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!"));
sourcepub fn blue(item: T) -> Paint<T>
pub fn blue(item: T) -> Paint<T>
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!"));
sourcepub fn magenta(item: T) -> Paint<T>
pub fn magenta(item: T) -> Paint<T>
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!"));
sourcepub fn cyan(item: T) -> Paint<T>
pub fn cyan(item: T) -> Paint<T>
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!"));
sourcepub fn white(item: T) -> Paint<T>
pub fn white(item: T) -> Paint<T>
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!"));
sourcepub fn style(&self) -> Style
pub fn style(&self) -> Style
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());
sourcepub fn inner(&self) -> &T
pub fn inner(&self) -> &T
Retrieves a borrow to the inner item.
use yansi::Paint;
let x = Paint::red("Hello, world!");
assert_eq!(*x.inner(), "Hello, world!");
sourcepub fn with_style(self, style: Style) -> Paint<T>
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, 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!"));
sourcepub fn mask(self) -> Paint<T>
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());
sourcepub fn wrap(self) -> Paint<T>
pub fn wrap(self) -> Paint<T>
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());
sourcepub fn fg(self, color: Color) -> Paint<T>
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));
sourcepub fn bg(self, color: Color) -> Paint<T>
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));
sourcepub fn bold(self) -> Paint<T>
pub fn bold(self) -> Paint<T>
Enables the bold style on self
.
use yansi::Paint;
println!("Using bold: {}", Paint::new("hi").bold());
sourcepub fn dimmed(self) -> Paint<T>
pub fn dimmed(self) -> Paint<T>
Enables the dimmed style on self
.
use yansi::Paint;
println!("Using dimmed: {}", Paint::new("hi").dimmed());
sourcepub fn italic(self) -> Paint<T>
pub fn italic(self) -> Paint<T>
Enables the italic style on self
.
use yansi::Paint;
println!("Using italic: {}", Paint::new("hi").italic());
sourcepub fn underline(self) -> Paint<T>
pub fn underline(self) -> Paint<T>
Enables the underline style on self
.
use yansi::Paint;
println!("Using underline: {}", Paint::new("hi").underline());
sourcepub fn blink(self) -> Paint<T>
pub fn blink(self) -> Paint<T>
Enables the blink style on self
.
use yansi::Paint;
println!("Using blink: {}", Paint::new("hi").blink());
sourcepub fn invert(self) -> Paint<T>
pub fn invert(self) -> Paint<T>
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());
sourcepub fn strikethrough(self) -> Paint<T>
pub fn strikethrough(self) -> Paint<T>
Enables the strikethrough style on self
.
use yansi::Paint;
println!("Using strikethrough: {}", Paint::new("hi").strikethrough());
source§impl Paint<()>
impl Paint<()>
sourcepub fn disable()
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());
sourcepub fn enable()
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());
sourcepub fn is_enabled() -> bool
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());
sourcepub fn enable_windows_ascii() -> bool
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§
source§impl<T: Ord> Ord for Paint<T>
impl<T: Ord> Ord for Paint<T>
source§impl<T: PartialEq> PartialEq for Paint<T>
impl<T: PartialEq> PartialEq for Paint<T>
source§impl<T: PartialOrd> PartialOrd for Paint<T>
impl<T: PartialOrd> PartialOrd for Paint<T>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more