Struct ShapedText 

pub struct ShapedText {
    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_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.

+- ShapedText --------------------------------+
|               +---+---+---+---+---+---+---+ |
| 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 ShapedText. 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 ShapedText

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_rtl: bool

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

Implementations

impl ShapedText

pub(crate) fn new(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( 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 ShapedText 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 ShapedText.

pub fn is_empty(&self) -> bool

Whether or not this ShapedText has any glyphs.

pub fn character_count(&self) -> usize

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

pub fn is_whitespace(&self) -> bool

Whether or not this ShapedText is entirely white space.

pub fn ends_with_whitespace(&self) -> bool

Whether or not this ShapedText ends with whitespace.

pub fn total_word_separators(&self) -> usize

The number of word separators in this ShapedText.

pub fn total_characters(&self) -> usize

The number of characters that were consumed to produce this ShapedText. Some characters correspond 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 ShapedText 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 ShapedText

fn clone(&self) -> ShapedText

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShapedText

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShapedText

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MallocSizeOf for ShapedText

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 ShapedText

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

where __S: Serializer,

Serialize this value into the given Serde serializer.