Struct GlyphStore 

pub struct GlyphStore {
    glyphs: Vec<GlyphEntry>,
    detailed_glyphs: Vec<DetailedGlyphEntry>,
    total_advance: Au,
    total_characters: usize,
    total_word_separators: usize,
    is_whitespace: bool,
    ends_with_whitespace: bool,
    is_single_preserved_newline: bool,
    is_rtl: bool,
}

Stores the glyph data belonging to a text run.

Simple glyphs are stored inline in the entry_buffer, detailed glyphs are stored as pointers into the detail_store.

+- GlyphStore --------------------------------+
|               +---+---+---+---+---+---+---+ |
| entry_buffer: |   | s |   | s |   | s | s | |  d = detailed
|               +-|-+---+-|-+---+-|-+---+---+ |  s = simple
|                 |       |       |           |
|                 |   +---+-------+           |
|                 |   |                       |
|               +-V-+-V-+                     |
| detail_store: | d | d |                     |
|               +---+---+                     |
+---------------------------------------------+

Fields

glyphs: Vec<GlyphEntry>

A collection of GlyphEntrys within the GlyphStore. Each GlyphEntry maybe simple or detailed. When detailed, there will be a corresponding entry in Self::detailed_glyphs.

detailed_glyphs: Vec<DetailedGlyphEntry>

A vector of glyphs that cannot fit within a single GlyphEntry or that correspond to 0 or more than 1 character in the original string.

total_advance: Au

A cache of the advance of the entire glyph store.

total_characters: usize

The number of characters that correspond to the glyphs in this GlyphStore

total_word_separators: usize

A cache of the number of word separators in the entire glyph store. See https://drafts.csswg.org/css-text/#word-separator.

is_whitespace: bool

Whether or not this glyph store contains only glyphs for whitespace.

ends_with_whitespace: bool

Whether or not this glyph store ends with whitespace glyphs. Typically whitespace glyphs are placed in a separate store, but that may not be the case with white-space: break-spaces.

is_single_preserved_newline: bool

Whether or not this glyph store contains only a single glyph for a single preserved newline.

is_rtl: bool

Whether or not this GlyphStore has right-to-left text, which has implications about the order of the glyphs in the store.

Implementations

impl GlyphStore

pub(crate) fn new(text: &str, length: usize, options: &ShapingOptions) -> Self

Initializes the glyph store with the given capacity, but doesn’t actually add any glyphs.

Use the add_* methods to store glyph data.

pub(crate) fn with_shaped_glyph_data( font: &Font, text: &str, options: &ShapingOptions, shaped_glyph_data: &impl GlyphShapingResult, ) -> Self

This constructor turns shaping output from HarfBuzz into a glyph run to be used by layout. The idea here is that we add each glyph to the GlyphStore and track to which characters from the original string each glyph corresponds. HarfBuzz will either give us glyphs that correspond to characters left-to-right or right-to-left. Each character can produce multiple glyphs and multiple characters can produce one glyph. HarfBuzz just guarantees that the resulting character offsets are in monotone order.

pub fn total_advance(&self) -> Au

pub fn len(&self) -> usize

Return the number of glyphs stored in this GlyphStore.

pub fn is_empty(&self) -> bool

Whether or not this GlyphStore has any glyphs.

pub fn character_count(&self) -> usize

The number of characters (char) from the original string that produced this GlyphStore.

pub fn is_whitespace(&self) -> bool

Whether or not this GlyphStore is entirely whitepsace.

pub fn is_single_preserved_newline(&self) -> bool

Whether or not this GlyphStore is a single preserved newline.

pub fn ends_with_whitespace(&self) -> bool

Whether or not this GlyphStore ends with whitespace.

pub fn total_word_separators(&self) -> usize

The number of word separators in this GlyphStore.

pub fn total_characters(&self) -> usize

The number of characters that were consumed to produce this GlyphStore. Some characters correpond to more than one glyph and some glyphs correspond to more than one character.

pub(crate) fn add_glyph(&mut self, character: char, glyph: &ShapedGlyph)

Adds glyph that corresponds to a single character (as far we know) in the originating string.

fn add_detailed_glyph( &mut self, shaped_glyph: &ShapedGlyph, character: Option<char>, character_count: usize, )

fn extend_previous_glyph_by_character(&mut self)

fn add_glyph_for_current_character( &mut self, shaped_glyph: &ShapedGlyph, options: &ShapingOptions, )

fn ensure_last_glyph_is_detailed(&mut self) -> usize

If the last glyph added to this GlyphStore was a simple glyph, convert it to a detailed one. In either case, return the index into Self::detailed_glyphs for the most recently added glyph.

pub fn glyphs(&self) -> impl Iterator<Item = GlyphInfo<'_>> + use<'_>

Trait Implementations

impl Clone for GlyphStore

fn clone(&self) -> GlyphStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlyphStore

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GlyphStore

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MallocSizeOf for GlyphStore

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Serialize for GlyphStore

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.