Enum Bevel 

#[non_exhaustive]
pub enum Bevel {
    Raised,
    Inset,
    RaisedOpen,
}

Which way the light falls across a two-tone edge.

The whole content of a bevel, once colour and thickness are deferred. The light is always assumed to come from the top left: every consumer measured agreed on that and none of them ever varied it, so it is an invariant here rather than a parameter.

The two corners that belong to both edges

Top-right and bottom-left are where the lit run meets the shaded one, and the description’s claim is that they belong to both. How a renderer says that is its own business, because the answer is bounded by resolution and not by taste:

• A terminal cell is roughly 8x17 device pixels, so giving the whole corner to one tone thickens that edge by a cell and reads as one run overrunning the other. A half-cell glyph divides the cell already, so makeover-tui splits it and recovers real information. Its box-drawing fallback cannot: a single stroke has no half to give, so there both corners go to dark.
• A pixel bevel is a one-point stroke by default, which makes the corner a one-point square. There is nothing to divide — a diagonal seam across one point is sub-pixel, and antialiasing renders it as the blend a mitred join already produces. So makeover-immediate mitres and is not diverging; it is the same rule at a resolution where the split degenerates.

Stated here so the difference reads as a decision rather than as drift. A renderer with room to divide the corner should; one without should mitre or pick the shaded tone, and neither is a bug. #[non_exhaustive] for Depth’s reason: an edge this renderer has no drawing for should cost it a wildcard arm rather than a compile error and a wait on someone else’s publish.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Raised

Lit from the top left: light on top and left, dark on bottom and right.

Inset

The same edge inverted, which is also the pressed state of anything that draws itself Bevel::Raised.

RaisedOpen

Raised with the bottom run left off, so the surface continues into whatever sits directly under it.

The chosen folder tab, and the reason this is an edge rather than a stylesheet trick in one renderer. A tab that comes forward but keeps a closed bottom reads as a chip resting near its pane; the open run is what makes it read as the front of the pane itself. Every renderer can say it: a browser drops the vertical offset on the dark shadow, a terminal draws three sides of a box, and a pixel renderer draws its shaded polyline as two points instead of three.

It carries no inverse. Pressing one inverts to Inset like any other raised thing, because a control held down is not joined to anything.

Implementations

impl Bevel

pub const fn edges(self) -> (Edge, Edge)

The edge intents, as (top_left, bottom_right).

Split out from any painting because the inversion is the idea, and it is the one part every renderer implements identically.

pub const fn draws_bottom(self) -> bool

Whether the shaded run closes the bottom of the box.

True for every edge but RaisedOpen, so a renderer that does not ask draws what it always drew.

pub const fn pressed(self) -> Self

Pressing inverts. A raised control reads as inset while held.

Stated here rather than left to each consumer because a cascade can carry a pressed state and an immediate-mode renderer cannot: audiofiles resolves this per call site, eighteen times.

Trait Implementations

impl Clone for Bevel

fn clone(&self) -> Bevel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Bevel

impl Debug for Bevel

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

Formats the value using the given formatter.

impl Eq for Bevel

impl Hash for Bevel

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 Bevel

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Bevel