Struct Finish 

pub struct Finish { /* private fields */ }

What one surface role is made of: the painter set that draws it and that set’s parameters.

In a document a role names its painter set ("painter") beside the set’s own parameters, the ones the set declares (crate::part_paint::PartPainter::params):

Document	Look
{ "painter": "block" }	flat, square to the border
{ "painter": "default" }	the design language’s opaque surfaces
{ "painter": "default", "blur": 24, "tint": 0.72, "saturation": 1 }	the blurred backdrop under the ground at a tint
{ "painter": "glass", "blur": …, "tint": …, "saturation": …, "refraction": …, "edge_highlight": …, "specular": … }	the same, bent and lit

A set this build does not have, a parameter the set does not declare and a required one left out are not admitted.

The toolkit itself understands three parameters, whichever set states them: blur (how far the backdrop is blurred, logical pixels), tint (the ground’s opacity over it) and saturation. A role that states any of them lets what is below it through (Finish::translucent).

Implementations

impl Finish

pub fn new<N>( set: PainterSet, params: impl IntoIterator<Item = (N, f32)>, ) -> Result<Finish, &'static str>

where N: Into<String>,

set with params, as the set declares them: every parameter it requires stated, none it does not declare.

pub fn named<N>( name: &str, params: impl IntoIterator<Item = (N, f32)>, ) -> Result<Finish, &'static str>

where N: Into<String>,

The set a document calls name, with params.

pub fn shader(&self) -> &Source

The theme’s own surface shader, for the shader set; empty otherwise.

pub fn with_shader(self, source: Source) -> Finish

This finish with source as its surface shader.

pub fn solid() -> Finish

The design language’s opaque surface: the Default set as it is.

pub fn flat() -> Finish

A flat surface: the Block set.

pub fn frosted(blur: f32, tint: f32, saturation: f32) -> Finish

The Default set showing what is below, blurred by blur logical pixels, its colour scaled by saturation, under the ground at tint opacity.

pub fn stock_floating() -> Finish

The stock floating material: the design language’s blurred panel.

pub fn stock_glass() -> Finish

The stock glass material: what a bar and the floating chrome are made of where a person asks to see what lies below — the backdrop blurred, left mostly to show and a little bent and lit at the rim, so a glass bar reads as glass over any wallpaper rather than as its ground. Its tint stays high enough that the theme’s ink keeps the contrast material_band holds every backdrop to, in light and in dark.

pub fn set(&self) -> &PainterSet

The set that draws this finish.

pub fn painter(&self) -> &str

The set’s name, as a document names it.

pub fn params(&self) -> &Arc<[Param]>

The parameters the document states, in the set’s order.

pub fn param(&self, name: &str) -> Option<f32>

The parameter name, where the document states it.

pub fn translucent(&self) -> bool

Whether the role lets what is below it through: it states a blur, a tint or a saturation.

pub fn blur(&self) -> f32

The backdrop blur, logical pixels; 0 where none is stated.

pub fn tint(&self) -> f32

The tint’s opacity over the backdrop; 1 where none is stated.

pub fn saturation(&self) -> f32

The backdrop’s saturation; 1 where none is stated.

pub fn hairline(&self) -> bool

Whether the role draws the hairline the design language gives it: every set’s surfaces but Block’s, which carry the border alone.

pub fn opaque(&self) -> &Finish

The finish actually painted where nothing may be translucent (reduced transparency, high contrast): the toolkit’s own sets become solid, Block staying flat; a theme’s own set keeps drawing, every backdrop it asks for shown as its fallback.

pub fn forced(&self) -> &Finish

The finish painted under forced colours: what they guarantee is not a theme’s set to keep, so always the toolkit’s own, solid (Block staying flat).

pub fn validate(&self) -> Result<(), &'static str>

Structural check: every parameter finite and in the band its set admits, and a shader a theme stated is a surface shader (crate::tokens::shader::Source::validate).

pub fn usable(&self) -> Finish

This finish with every parameter held to the band its set is built at.

pub fn with_translucency(&self, strength: f32) -> Finish

This finish at strength of its translucency: 0 turns its blur off and its tint opaque (and a glass body’s light with it), 1 leaves it as it is. An opaque finish stays as it is.

Trait Implementations

impl Clone for Finish

fn clone(&self) -> Finish

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Finish

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Finish

fn deserialize<D>( deserializer: D, ) -> Result<Finish, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Finish

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

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.