Trait ansi_colours::AsRGB

source ·

pub trait AsRGB {
    fn as_u32(&self) -> u32;

    fn to_ansi256(&self) -> u8 { ... }
}

Expand description

Type which (can) represent an sRGB colour. Used to provide overloaded versions of ansi256_from_rgb function.

Required Methods§

source

fn as_u32(&self) -> u32

Returns representation of the sRGB colour as a 24-bit 0xRRGGBB integer.

Provided Methods§

source

fn to_ansi256(&self) -> u8

Returns index of a colour in 256-colour ANSI palette approximating given sRGB colour.

This is provided by default and uses Self::as_u32 to determine 24-bit sRGB representation of the colour.

An implementation should provide its own definition if it can offer a more direct approximation. For example, if Self represents shades of grey, it’s faster to use ansi256_from_grey than relay on to_u32 conversion; or if it represents a variant which can store index in the palette or an RGB colour, it’s better to either return the index or perform approximation depending on the variant.

Examples found in repository ?

src/lib.rs (line 154)

pub fn ansi256_from_rgb<C: AsRGB>(rgb: C) -> u8 { rgb.to_ansi256() }

More examples

Hide additional examples

src/impls.rs (line 202)

    fn to_ansi256(&self) -> u8 {
        match self.clone() {
            Self::Black => 0,
            Self::Red => 1,
            Self::Green => 2,
            Self::Yellow => 3,
            Self::Blue => 4,
            Self::Purple => 5,
            Self::Cyan => 6,
            Self::White => 7,
            Self::Fixed(idx) => idx,
            Self::RGB(r, g, b) => (r, g, b).to_ansi256(),
        }
    }
}

#[cfg(feature = "ansi_term")]
impl super::ColourExt for ansi_term::Colour {
    /// Constructs a `Fixed` colour which approximates given sRGB colour.
    ///
    /// This implementation is present only if `ansi_term` crate feature is
    /// enabled.
    ///
    /// # Examples
    ///
    /// ```
    /// use ansi_colours::ColourExt;
    /// use ansi_term::Colour;
    ///
    /// assert_eq!(Colour::Fixed( 16), Colour::approx_rgb(  0,   0,   0));
    /// assert_eq!(Colour::Fixed( 16), Colour::approx_rgb(  0,   1,   2));
    /// assert_eq!(Colour::Fixed( 67), Colour::approx_rgb( 95, 135, 175));
    /// assert_eq!(Colour::Fixed(231), Colour::approx_rgb(255, 255, 255));
    /// ```
    #[inline]
    fn approx_rgb(r: u8, g: u8, b: u8) -> Self {
        Self::Fixed(ansi256_from_rgb((r, g, b)))
    }

    /// Converts the colour into 256-colour-compatible format.
    ///
    /// If the colour represents an RGB colour, converts it into a `Fixed`
    /// variant using [`ansi256_from_rgb`] function.  Otherwise, returns the
    /// colour unchanged.
    ///
    /// This implementation is present only if `ansi_term` crate feature is
    /// enabled.
    ///
    /// # Examples
    ///
    /// ```
    /// use ansi_colours::ColourExt;
    /// use ansi_term::Colour;
    ///
    /// assert_eq!(Colour::Red,        Colour::Red.to_256());
    /// assert_eq!(Colour::Fixed( 11), Colour::Fixed(11).to_256());
    /// assert_eq!(Colour::Fixed( 16), Colour::RGB(  0,   0,   0).to_256());
    /// assert_eq!(Colour::Fixed( 16), Colour::RGB(  0,   1,   2).to_256());
    /// assert_eq!(Colour::Fixed( 67), Colour::RGB( 95, 135, 175).to_256());
    /// assert_eq!(Colour::Fixed(231), Colour::RGB(255, 255, 255).to_256());
    /// ```
    #[inline]
    fn to_256(&self) -> Self {
        if let Self::RGB(r, g, b) = self {
            Self::Fixed(ansi256_from_rgb((*r, *g, *b)))
        } else {
            *self
        }
    }

    /// Converts the colour into sRGB.
    ///
    /// Named colours (`Black`, `Red` etc. through `White`) are treated like
    /// `Fixed` colours with indexes 0 through 7.  `Fixed` colours are converted
    /// into sRGB using [`rgb_from_ansi256`] function.  `RGB` colours are
    /// returned unchanged.
    ///
    /// This implementation is present only if `ansi_term` crate feature is
    /// enabled.
    ///
    /// # Examples
    ///
    /// ```
    /// use ansi_colours::ColourExt;
    /// use ansi_term::Colour;
    ///
    /// assert_eq!((  0,   0,   0), Colour::Fixed( 16).to_rgb());
    /// assert_eq!(( 95, 135, 175), Colour::Fixed( 67).to_rgb());
    /// assert_eq!((255, 255, 255), Colour::Fixed(231).to_rgb());
    /// assert_eq!((238, 238, 238), Colour::Fixed(255).to_rgb());
    /// assert_eq!(( 42,  24,   0), Colour::RGB(42, 24, 0).to_rgb());
    /// ```
    #[inline]
    fn to_rgb(&self) -> (u8, u8, u8) {
        let idx = match self.clone() {
            Self::Black => 0,
            Self::Red => 1,
            Self::Green => 2,
            Self::Yellow => 3,
            Self::Blue => 4,
            Self::Purple => 5,
            Self::Cyan => 6,
            Self::White => 7,
            Self::Fixed(idx) => idx,
            Self::RGB(r, g, b) => return (r, g, b),
        };
        rgb_from_ansi256(idx)
    }
}

#[cfg(feature = "termcolor")]
impl AsRGB for termcolor::Color {
    /// Returns sRGB colour corresponding to escape code represented by
    /// [`termcolor::Color`].
    ///
    /// Behaves slightly differently depending on the variant of the enum.
    /// - For named colour variants (`Black`, `Red` etc. up till `White`),
    ///   returns corresponding system colour with indexes going from 0 to 7.
    /// - Similarly, for `Ansi256` variant returns colour corresponding to
    ///   specified index.  See [`rgb_from_ansi256`](`rgb_from_ansi256`).
    /// - Lastly, for `Rgb` variant converts it to 24-bit `0xRRGGBB`
    ///   representation.
    ///
    /// This implementation is present only if `termcolor` crate feature is
    /// enabled.
    #[inline]
    fn as_u32(&self) -> u32 {
        match self.clone() {
            Self::Black => ansi256::ANSI_COLOURS[0],
            Self::Blue => ansi256::ANSI_COLOURS[4],
            Self::Green => ansi256::ANSI_COLOURS[2],
            Self::Red => ansi256::ANSI_COLOURS[1],
            Self::Cyan => ansi256::ANSI_COLOURS[6],
            Self::Magenta => ansi256::ANSI_COLOURS[5],
            Self::Yellow => ansi256::ANSI_COLOURS[3],
            Self::White => ansi256::ANSI_COLOURS[7],
            Self::Ansi256(idx) => ansi256::ANSI_COLOURS[idx as usize],
            Self::Rgb(r, g, b) => (r, g, b).as_u32(),
            _ => unreachable!(),
        }
    }

    /// Returns index of a colour in 256-colour ANSI palette approximating given
    /// sRGB colour.
    ///
    /// Behaves slightly differently depending on the variant of the enum.
    /// - For named colour variants (`Black`, `Red` etc. up till `White`),
    ///   returns index going from 0 to 7.
    /// - For `Ansi256` variant simply returns index encoded in the variant.
    /// - Lastly, for `Rgb` variant, approximates the colour and returns index
    ///   of closest colour in 256-colour palette.
    ///
    /// This implementation is present only if `termcolor` crate feature is
    /// enabled.
    ///
    /// # Examples
    ///
    /// ```
    /// use ansi_colours::AsRGB;
    ///
    /// assert_eq!(  0, termcolor::Color::Black.to_ansi256());
    /// assert_eq!(  7, termcolor::Color::White.to_ansi256());
    /// assert_eq!( 42, termcolor::Color::Ansi256(42).to_ansi256());
    /// assert_eq!( 16, termcolor::Color::Rgb(  0,   0,   0).to_ansi256());
    /// assert_eq!( 16, termcolor::Color::Rgb(  1,   1,   1).to_ansi256());
    /// assert_eq!( 16, termcolor::Color::Rgb(  0,   1,   2).to_ansi256());
    /// assert_eq!( 67, termcolor::Color::Rgb( 95, 135, 175).to_ansi256());
    /// assert_eq!(231, termcolor::Color::Rgb(255, 255, 255).to_ansi256());
    /// ```
    #[inline]
    fn to_ansi256(&self) -> u8 {
        match self.clone() {
            Self::Black => 0,
            Self::Blue => 4,
            Self::Green => 2,
            Self::Red => 1,
            Self::Cyan => 6,
            Self::Magenta => 5,
            Self::Yellow => 3,
            Self::White => 7,
            Self::Ansi256(idx) => idx,
            Self::Rgb(r, g, b) => (r, g, b).to_ansi256(),
            _ => unreachable!(),
        }
    }

Trait ansi_colours::AsRGB

Required Methods§

fn as_u32(&self) -> u32

Provided Methods§

fn to_ansi256(&self) -> u8

Implementations on Foreign Types§

impl AsRGB for u32

fn as_u32(&self) -> u32

impl AsRGB for (u8, u8, u8)

fn as_u32(&self) -> u32

impl AsRGB for [u8; 3]

fn as_u32(&self) -> u32

impl<'a, T: AsRGB + ?Sized> AsRGB for &'a T

fn as_u32(&self) -> u32

impl<C: Component> AsRGB for RGB<C>

fn as_u32(&self) -> u32

impl<C: Component> AsRGB for Gray<C>

fn to_ansi256(&self) -> u8

fn as_u32(&self) -> u32

impl<C: Component> AsRGB for BGR<C>

fn as_u32(&self) -> u32

impl AsRGB for Colour

fn as_u32(&self) -> u32

fn to_ansi256(&self) -> u8

impl AsRGB for Color

fn as_u32(&self) -> u32

fn to_ansi256(&self) -> u8

Implementors§