Struct Color 

pub struct Color {
    pub r: u8,
    pub g: u8,
    pub b: u8,
    pub a: u8,
}

RGBA color representation with 8-bit components

Fields

r: u8

Red component

g: u8

Green component

b: u8

Blue component

a: u8

Alpha component

Implementations

impl Color

pub const WHITE: Self

White (FFFFFF)

pub const BLACK: Self

Black (000000)

pub const RED: Self

Red (FF0000)

pub const GREEN: Self

Green (00FF00)

pub const BLUE: Self

Blue (0000FF)

pub const CYAN: Self

Cyan (00FFFF)

pub const MAGENTA: Self

Magenta (FF00FF)

pub const YELLOW: Self

Yellow (FFFF00)

pub const fn gray(shade: u8) -> Self

Create a grayscale color from a single intensity value

Arguments

• shade - Gray intensity

Example

use simple_color::Color;

let gray = Color::gray(0x80);
let dark_gray = Color::gray(0x40);
let light_gray = Color::gray(0xC0);
let black = Color::gray(0);
let white = Color::gray(0xFF);

assert_eq!(gray, Color::rgb(0x80, 0x80, 0x80));
assert_eq!(black, Color::BLACK);
assert_eq!(white, Color::WHITE);

pub const fn rgb(r: u8, g: u8, b: u8) -> Self

Create an opaque RGB color

Arguments

• r - Red component
• g - Green component
• b - Blue component

Example

use simple_color::Color;

let cyan = Color::rgb(0, 0xFF, 0xFF);
assert_eq!(cyan, Color::CYAN);

pub const fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self

Create a translucent RGBA color

Arguments

• r - Red component
• g - Green component
• b - Blue component
• a - Alpha component

Example

use simple_color::Color;

let semi_transparent_red = Color::rgba(0xFF, 0x00, 0x00, 0x80);
assert_eq!(semi_transparent_red, Color::RED.a(0x80));

pub const fn r(self, r: u8) -> Self

Create a copy with modified red component

Arguments

• r - New red value

Example

use simple_color::Color;

let dark_red = Color::BLACK.r(0x80);
assert_eq!(dark_red, Color::rgb(0x80, 0, 0));

pub const fn g(self, g: u8) -> Self

Create a copy with modified green component

Arguments

• g - New green value

Example

use simple_color::Color;

let yellow_green = Color::RED.g(0x80);
assert_eq!(yellow_green, Color::rgb(0xFF, 0x80, 0));

pub const fn b(self, b: u8) -> Self

Create a copy with modified blue component

Arguments

• b - New blue value

Example

use simple_color::Color;

let light_yellow = Color::WHITE.b(0x80);
assert_eq!(light_yellow, Color::rgb(0xFF, 0xFF, 0x80));

pub const fn a(self, a: u8) -> Self

Create a copy with modified alpha component

Arguments

• a - New alpha value

Example

use simple_color::Color;

let semi_transparent_blue = Color::BLUE.a(0x80);
assert_eq!(semi_transparent_blue, Color::rgba(0x00, 0x00, 0xFF, 0x80));

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Color

impl Debug for Color

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

Formats the value using the given formatter.

impl Default for Color

fn default() -> Color

Returns the “default value” for a type.

impl Eq for Color

impl FromStr for Color

fn from_str(name: &str) -> Result<Self, Self::Err>

Parse color from hexadecimal string.

Supported formats:

• Grayscale - 1 or 2 characters representing brightness
• RGB - “RGB” or “RRGGBB”
• RGBA - “RGBA” or “RRGGBBAA”

Example

use simple_color::{Color, ColorParsingError};

let red: Color = "FF0000".parse().unwrap();
assert_eq!(red, Color::RED);

let semi_transparent_orange: Color = "ff800080".parse().unwrap();
assert_eq!(semi_transparent_orange, Color::rgba(0xFF, 0x80, 0, 0x80));

let gray: Color = "80".parse().unwrap();
assert_eq!(gray, Color::gray(0x80));

let invalid_char: Result<Color, _> = "80FG00".parse();
assert_eq!(invalid_char, Err(ColorParsingError::InvalidChar('G')));

let invalid_length: Result<Color, _> = "FF80000".parse();
assert_eq!(invalid_length, Err(ColorParsingError::InvalidLength(7)));

type Err = ColorParsingError

The associated error which can be returned from parsing.

impl PartialEq for Color

fn eq(&self, other: &Color) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Color