Struct Color 

#[repr(C)]
pub struct Color {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}

A straight-alpha sRGB colour with f32 channels in 0.0..=1.0.

Build one from bytes, a hex literal or floats, and derive the rest of a palette with Color::mix and Color::with_alpha:

use kui_core::Color;

let brand = Color::hex(0x3b5bd4ff);
assert_eq!(brand, Color::rgb8(0x3b, 0x5b, 0xd4));
let hover = brand.mix(Color::WHITE, 0.1); // a little lighter
let wash = brand.with_alpha(0.25);
assert!(hover.r > brand.r && wash.a == 0.25);
assert_eq!(brand.to_hex(), 0x3b5bd4ff);

Fields

r: f32

g: f32

b: f32

a: f32

Implementations

impl Color

pub const TRANSPARENT: Color

pub const WHITE: Color

pub const BLACK: Color

pub fn rgba(r: f32, g: f32, b: f32, a: f32) -> Color

pub fn rgb8(r: u8, g: u8, b: u8) -> Color

pub fn rgba8(r: u8, g: u8, b: u8, a: u8) -> Color

pub fn to_hex(&self) -> u32

This colour as 0xRRGGBBAA, rounded to eight bits a channel: what Color::hex reads.

pub fn hex(v: u32) -> Color

A colour from 0xRRGGBBAA.

pub fn with_alpha(self, a: f32) -> Color

pub fn is_visible(&self) -> bool

pub fn lerp(self, other: Color, t: f32) -> Color

Every channel, alpha included, t of the way to other — what a tween does to a colour. Self::mix keeps this colour’s alpha.

pub fn mix(self, other: Color, t: f32) -> Color

This colour moved t of the way toward other, per channel, with self’s alpha kept: mix(WHITE, 0.1) is “a little lighter” and mix(BLACK, 0.1) “a little darker”, which is how a palette is built from one colour (widgets::button_palette).

Straight sRGB, not a perceptual space, and the same interpolation a colour transition does. t outside 0..=1 extrapolates rather than clamping, so a caller can overshoot on purpose.

pub fn luminance(self) -> f32

WCAG relative luminance, 0 (black) to 1 (white): the number a contrast decision is made from — “is this background light enough to want dark text” — rather than the average of the channels, which would call a saturated blue and a saturated green equally bright. Alpha is not in it; a translucent colour’s luminance is the luminance of what it would be over nothing.

pub fn contrast(self, other: Color) -> f32

WCAG’s contrast ratio between two opaque colours, 1:1 to 21:1 — the number “4.5:1” (body text) and “3:1” (large text, UI edges, a focus ring) are ratios of. Symmetric. The arithmetic a palette is checked with; which pairs to check is the theme’s business.

pub fn toward_contrast( self, toward: Color, on: Color, ratio: f32, from: f32, ) -> Color

self moved toward toward in steps of 0.05, starting from of the way there, until it clears ratio on on — the one loop behind “an accent that can be seen on this base”. Reaches toward itself at the end, so pick one that clears the ratio on its own (black or white on any base does), and the cap is a floor rather than a give-up. A colour that already reads at from comes back as that mix, so from = 0.0 paints one verbatim.

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<(), Error>

Formats the value using the given formatter.

impl Default for Color

fn default() -> Color

Returns the “default value” for a type.

impl From<Color> for Stop

fn from(color: Color) -> Stop

Converts to this type from the input type.

impl PartialEq for Color

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Color