[][src]Struct rusttype::Font

pub struct Font<'a> { /* fields omitted */ }

A single font. This may or may not own the font data.

Methods

impl<'a> Font<'a>[src]

pub fn v_metrics(&self, scale: Scale) -> VMetrics[src]

The "vertical metrics" for this font at a given scale. These metrics are shared by all of the glyphs in the font. See VMetrics for more detail.

pub fn glyph_count(&self) -> usize[src]

The number of glyphs present in this font. Glyph identifiers for this font will always be in the range 0..self.glyph_count()

pub fn glyph<C: Into<CodepointOrGlyphId>>(&self, id: C) -> Option<Glyph>[src]

Returns the corresponding glyph for a Unicode code point or a glyph id for this font. If id corresponds to a glyph identifier, the identifier must be valid (smaller than self.glyph_count()), otherwise None is returned.

Note that code points without corresponding glyphs in this font map to the "undef" glyph, glyph 0.

Important traits for GlyphIter<'a, I>
pub fn glyphs_for<I: Iterator>(&self, itr: I) -> GlyphIter<I> where
    I::Item: Into<CodepointOrGlyphId>, 
[src]

A convenience function.

Returns an iterator that produces the glyphs corresponding to the code points or glyph ids produced by the given iterator itr.

This is equivalent in behaviour to itr.map(|c| font.glyph(c).unwrap()).

Important traits for LayoutIter<'a, 'b>
pub fn layout<'b, 'c>(
    &'b self,
    s: &'c str,
    scale: Scale,
    start: Point<f32>
) -> LayoutIter<'b, 'c>
[src]

A convenience function for laying out glyphs for a string horizontally. It does not take control characters like line breaks into account, as treatment of these is likely to depend on the application.

Note that this function does not perform Unicode normalisation. Composite characters (such as ö constructed from two code points, ¨ and o), will not be normalised to single code points. So if a font does not contain a glyph for each separate code point, but does contain one for the normalised single code point (which is common), the desired glyph will not be produced, despite being present in the font. Deal with this by performing Unicode normalisation on the input string before passing it to layout. The crate unicode-normalization is perfect for this purpose.

Calling this function is equivalent to a longer sequence of operations involving glyphs_for, e.g.

font.layout("Hello World!", scale, start)

produces an iterator with behaviour equivalent to the following:

font.glyphs_for("Hello World!".chars())
    .scan((None, 0.0), |&mut (mut last, mut x), g| {
        let g = g.scaled(scale);
        let w = g.h_metrics().advance_width
            + last.map(|last| font.pair_kerning(scale, last, g.id())).unwrap_or(0.0);
        let next = g.positioned(start + vector(x, 0.0));
        last = Some(next.id());
        x += w;
        Some(next)
    })

pub fn pair_kerning<A, B>(&self, scale: Scale, first: A, second: B) -> f32 where
    A: Into<CodepointOrGlyphId>,
    B: Into<CodepointOrGlyphId>, 
[src]

Returns additional kerning to apply as well as that given by HMetrics for a particular pair of glyphs.

Trait Implementations

impl<'a> Clone for Font<'a>[src]

Auto Trait Implementations

impl<'a> Sync for Font<'a>

impl<'a> Send for Font<'a>

impl<'a> Unpin for Font<'a>

impl<'a> UnwindSafe for Font<'a>

impl<'a> RefUnwindSafe for Font<'a>

Blanket Implementations

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]