Struct RhythmFontSpec 

pub struct RhythmFontSpec { /* private fields */ }

Available on crate feature gpui only.

The pre-resolve identity of a RhythmFont: the requested Font, size, line rhythms, and grid size as one hashable value — the cache key for caller-owned typography catalogs.

The crate deliberately keeps no font cache (gpui already caches Font → FontId and metrics); an app reusing resolved values across a document owns the map and its invalidation. Register font families before resolving any spec for them: gpui caches failed lookups, so clearing this caller-owned map after late registration cannot repair an earlier miss. Rebuild the map when typography settings change:

use std::collections::HashMap;

use gpui::{font, px, TextSystem};
use rhythm_gpui::{RhythmFont, RhythmFontSpec, RhythmGrid};

fn body(cache: &mut HashMap<RhythmFontSpec, RhythmFont>, ts: &TextSystem) -> RhythmFont {
    let spec = RhythmFontSpec::new(font("Noto Serif"), px(16.), 3, RhythmGrid::new(px(8.)));
    cache
        .entry(spec.clone())
        .or_insert_with(|| spec.resolve(ts))
        .clone()
}

Implementations

impl RhythmFontSpec

pub fn new( font: Font, font_size: Pixels, line_rhythms: u32, grid: RhythmGrid, ) -> Self

The spec for resolving font at font_size on grid with a line_rhythms-unit line height.

Panics

Panics when the font weight is zero, negative, or non-finite, when font_size is zero, negative, or non-finite, or when line_rhythms is zero.

pub fn font(&self) -> &Font

The requested gpui font configuration.

pub const fn font_size(&self) -> Pixels

The font size the metrics will be resolved at.

pub const fn line_rhythms(&self) -> u32

Line height in whole rhythm units.

pub fn grid(&self) -> RhythmGrid

The grid the font will be bound to.

pub fn resolve(&self, text_system: &TextSystem) -> RhythmFont

Resolve the spec into a RhythmFont — RhythmFont::resolve with this identity; see it for the fallback-resolution caveats.

pub fn resolve_covering( &self, text_system: &TextSystem, others: &[RhythmFontSpec], ) -> RhythmFont

Resolve this spec at a line height covering the ascent/descent envelope of every font in others — the catalog-build step that fixes one row budget over an explicit face set rather than per shaped line.

A line shapes to the maxima over its explicit font runs, so a style needs a line height covering the tallest mixture of every face the caller knows its runs can explicitly select: bold, inline code, or an explicit CJK or emoji face. others is that closed, caller-supplied catalog. Each listed Font is resolved through gpui — including the family fallback gpui chooses when that request is missing — but this method neither inspects text nor discovers glyph-level fallback faces selected later by the platform shaper.

gpui shapes all TextRuns in a line at one font size, so every spec must use this spec’s font_size and grid. Compatibility is checked before any font is resolved, then the resolved metrics are folded with RhythmLineMetrics::covering. The result is this spec’s font at the covering count — metrics, cap height, and baselines stay the primary face’s, only the line height grows. Nothing is shaped, so the count is a startup constant and every block’s height follows from its line count, which is what a virtualized renderer needs.

Keep placing each shaped line with its own ascent/descent at this font’s line_rhythms; with the height settled here, no explicit-run mixture of the covered set outgrows it. Resolve the run faces at that same count when their own metrics are used for placement — spec on the returned font carries it, and reproduces these metrics as usual.

use gpui::{font, px, FontWeight, TextSystem};
use rhythm_gpui::{RhythmFontSpec, RhythmGrid};

fn body(text_system: &TextSystem) -> rhythm_gpui::RhythmFont {
    let grid = RhythmGrid::new(px(8.));
    let mut bold = font("Georgia");
    bold.weight = FontWeight::BOLD;
    RhythmFontSpec::new(font("Georgia"), px(16.), 3, grid).resolve_covering(
        text_system,
        &[
            RhythmFontSpec::new(bold, px(16.), 3, grid),
            RhythmFontSpec::new(font("Menlo"), px(16.), 3, grid),
            RhythmFontSpec::new(font("Apple Color Emoji"), px(16.), 3, grid),
        ],
    )
}

Panics

Panics when a spec in others was built with a different font size or grid size.

Trait Implementations

impl Clone for RhythmFontSpec

fn clone(&self) -> RhythmFontSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RhythmFontSpec

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

Formats the value using the given formatter.

impl Eq for RhythmFontSpec

impl Hash for RhythmFontSpec

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 RhythmFontSpec

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RhythmFontSpec