Struct FontScaleCurve 

pub struct FontScaleCurve { /* private fields */ }

The sp → dp conversion the platform performs, sampled from the platform.

With no knots this is sp * scale. With knots it is the piecewise-linear function through them, extended past both ends by the ratio of the knot on that end — which is how the platform extends its own table, so a size below the first knot scales by the plain setting and one above the last keeps the last knot’s ratio.

A curve is Copy and rides in every crate::Density, which each layout node keeps and the measurement path passes by value, so its knots live in a table shared by every curve with the same knots, which it reaches by a thin pointer: a curve is 16 bytes.

Implementations

impl FontScaleCurve

pub const fn linear(scale: f32) -> Self

The plain multiplier: what every platform without a conversion table does, and what Android itself did before it had one.

pub fn from_samples(scale: f32, samples: &[(f32, f32)]) -> Self

A curve through samples, which are (sp, dp) pairs read from the platform in ascending sp order.

Samples that lie on the straight line between their neighbours are dropped, so a densely sampled table comes back as the handful of points that actually bend. Anything the platform could not have produced — an empty or unsorted set, a non-finite or non-positive value, or more bends than MAX_FONT_SCALE_KNOTS — is refused, and the caller gets the multiplier rather than a curve nobody measured. Samples that all lie on the multiplier’s own line are the multiplier, and come back as it, so a platform answering with the plain setting gives a curve equal to FontScaleCurve::linear.

pub fn scale(self) -> f32

The setting itself — what the user chose, whatever the table then does with an individual size. This is the number to report, not the number to multiply by.

pub fn is_linear(self) -> bool

Whether this is the plain multiplier, with no table behind it.

pub fn is_identity(self) -> bool

Whether resolving an Sp through this curve changes nothing at all.

Asked of the conversion and not of the representation: a platform that hands back a table while the setting sits at 1.0 hands back a table whose every knot maps a size to itself, and that is still nothing to do.

pub fn knots(self) -> &'static [(f32, f32)]

The knots, ascending by sp. Empty for a linear curve.

pub fn knot_count(self) -> usize

How many FontScaleCurve::knots there are.

pub fn fingerprint(self) -> u32

A cheap identity for cache keys: two curves that convert identically share it, and one that does not is overwhelmingly unlikely to.

pub fn sp_to_dp(self, sp: f32) -> f32

A size in scale-independent pixels, in dp.

This is FontScaleConverterImpl.convertSpToDp: the sign is carried separately, an exact hit on a knot returns that knot, a size outside the table scales by the ratio of the nearest end, and everything between two knots is interpolated.

Trait Implementations

impl Clone for FontScaleCurve

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FontScaleCurve

impl Debug for FontScaleCurve

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

Formats the value using the given formatter.

impl Default for FontScaleCurve

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for FontScaleCurve

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FontScaleCurve