Struct Face 

pub struct Face<'a> {
    pub name: &'a str,
    pub identity: &'a str,
    pub colour: AlphaColor<Srgb>,
    pub is_agent: bool,
    pub dimmed: bool,
    pub in_call: Option<f32>,
    pub scale: f64,
}

One person’s face in a stack.

Fields

name: &'a str

identity: &'a str

Their stable id: picks their picture and, without a colour, their hue.

colour: AlphaColor<Srgb>

is_agent: bool

dimmed: bool

Idle or away: the face dims.

in_call: Option<f32>

In a voice channel: a soft ring breathes around the face, at this level (ui::motion::Breathe); None when not in a call.

scale: f64

A wave’s bounce, as a scale (1 at rest; ui::motion::Attention).

Implementations

impl<'a> Face<'a>

pub fn new( name: &'a str, identity: &'a str, colour: AlphaColor<Srgb>, ) -> Face<'a>

impl Face<'_>

pub const GROUND_GAP: f64 = GAP

The gap of ground between a face’s disc and its colour ring.

pub const REACH: f64

How far a face’s ground reaches past its disc: the gap, the colour ring and the gap around it (the call ring, when shown, reaches further).

pub fn disc_in(outer: Rect) -> Rect

The disc of a face whose ring and gap fill outer exactly: where a caller with a fixed cell (a column at a screen edge, a list row) paints Self::paint so nothing reaches past the cell.

pub fn paint( &self, ctx: &mut PaintCtx<'_>, rect: Rect, ground: AlphaColor<Srgb>, )

Paint this face alone in rect over ground: the call ring, the ground gap, the colour ring and the face itself, quietened while idle. Where a caller lays faces out itself (a column at a screen edge, a list row), so a person still looks as they do in every stack.

Trait Implementations

impl<'a> Clone for Face<'a>

fn clone(&self) -> Face<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Face<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Face<'a>

fn eq(&self, other: &Face<'a>) -> 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<'a> StructuralPartialEq for Face<'a>