Enum Depth 

pub enum Depth {
    Flat,
    Raised,
    Well,
    Sunken,
}

How a region sits relative to the surface behind it.

Fill and bevel are named together because naming them apart is what let them disagree. Every consumer measured had at least one region carrying a raised bevel over a recessed fill: audiofiles fixed it in raised_frame and recorded the bug in its doc comment, and Balanced Breakfast still had twelve of them a year later. A single name for the pair makes that unrepresentable.

Variants

Flat

Level with its surroundings. No edge.

Raised

A card laid on the panel it sits in.

Well

A hole in the panel, with content down inside it. For anything the user looks into: a table body, a tag tree, a text field.

Sunken

Set back from what it sits on, by colour alone. No edge.

The one member carrying a fill without a bevel, so a renderer cannot assume the two arrive together. That is deliberate and it is still the pairing rule: both halves come off the same Depth, so they cannot disagree, and here one half is legitimately absent.

Distinct from Depth::Flat, which has no fill either and inherits. Recessed and level-with are different claims, and only one of them needs a colour.

Implementations

impl Depth

pub const fn bevel(self) -> Option<Bevel>

The edge this depth is drawn with, if it has one.

pub const fn fill(self) -> Option<Fill>

The surface this depth is filled with.

Depth::Flat has no fill of its own: it inherits whatever it sits on, which is the difference between level-with and painted-the-same-colour.

pub const fn pressed(self) -> Self

Pressing a raised region reads as a well, and nothing else moves.

Trait Implementations

impl Clone for Depth

fn clone(&self) -> Depth

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Depth

impl Debug for Depth

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

Formats the value using the given formatter.

impl Eq for Depth

impl Hash for Depth

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Depth

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Depth