Struct PresencePalette 

pub struct PresencePalette {
    pub lightness: f32,
    pub chroma: f32,
    pub colors: [AlphaColor<Srgb>; 12],
}

One colour per participant: PRESENCE_HUES at one OKLCH lightness and chroma, so they differ in hue only and no participant looks more important than another. Where sRGB cannot carry the full chroma at a hue (a light cyan) only that hue’s chroma drops; lightness never does.

Fields

lightness: f32

chroma: f32

colors: [AlphaColor<Srgb>; 12]

Implementations

impl PresencePalette

pub fn new(lightness: f32, chroma: f32) -> PresencePalette

pub fn get(&self, slot: usize) -> AlphaColor<Srgb>

Slot slot, wrapping past PRESENCE_LEN.

pub fn series(&self, index: usize) -> AlphaColor<Srgb>

The indexth colour of a data series (chart categories, tag colours): the same twelve hues, walked so the first six are at least 60° apart from each other (consecutive ones mostly 120°–180°), the next six fill the gaps, and the walk wraps past PRESENCE_LEN. Equal lightness and chroma keep every series equally loud.

pub fn hue(&self, hue: PresenceHue) -> AlphaColor<Srgb>

A person’s colour as this palette paints it.

pub fn of(&self, identity: AlphaColor<Srgb>) -> AlphaColor<Srgb>

An identity colour (a roster choice, a hashed id, an avatar colour) as this palette paints it: its hue at the palette’s lightness and chroma. Identities travel between devices and themes as colours; painting them through here keeps every participant equal on every ground. A grey identity has no hue and stays grey at the palette’s lightness: it is someone whose colour is not known yet (ui::presence::UNSETTLED_RGB), and a hue picked for them would be a colour they then change from.

pub fn ring_on( &self, identity: AlphaColor<Srgb>, ground: AlphaColor<Srgb>, ) -> AlphaColor<Srgb>

A person’s colour as the ring of their face on ground (identity as Self::of takes it): their palette colour, moved in lightness away from the ground, hue and chroma kept, only where it would not otherwise stand out from it as a mark (NON_TEXT_MIN_CONTRAST). The palette is tuned for windows and floating surfaces; a face on the desktop’s ground (the top bar) keeps its ring legible there too.

pub fn idle_on( &self, identity: AlphaColor<Srgb>, ground: AlphaColor<Srgb>, ) -> AlphaColor<Srgb>

A person’s colour while they are idle or away (identity as Self::of takes it), on ground: their hue kept, most of its chroma let go (IDLE_CHROMA), and moved toward the ground (IDLE_FADE of the way at most) only as far as it stays a mark against it (NON_TEXT_MIN_CONTRAST). A face dims without ever vanishing into the bar it sits on, whatever the hue and theme; where even the quieted colour would miss the floor, it moves away from the ground until it holds.

pub fn of_rgb(&self, _: (u8, u8, u8)) -> AlphaColor<Srgb>

Self::of for the (r, g, b) tuples presence identities are stored as.

Trait Implementations

impl Clone for PresencePalette

fn clone(&self) -> PresencePalette

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PresencePalette

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

Formats the value using the given formatter.

impl PartialEq for PresencePalette

fn eq(&self, other: &PresencePalette) -> 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 Copy for PresencePalette

impl StructuralPartialEq for PresencePalette