Struct ShapingQueue 

pub(crate) struct ShapingQueue<'a> {
    queue: Vec<ShapingQueueText>,
    text: &'a str,
    line_breaker: LineBreaker,
    byte_range: Range<usize>,
    character_range: Range<usize>,
    resolved_script: Option<Script>,
}

The ShapingQueue is responsible for shaping text during inline formatting context construction. It allows for shaping text across inline box boundaries. When pushing items to the queue, if the items are compatible pieces of text that can be shaped together, they are accumulated. The queue may be flushed in the given situations:

• An incompatible piece of text (different fonts or certain style properties) is pushed to the queue.
• A preserved newline or tab is pushed to the queue.
• An inline box breaks shaping via padding, border, margins or a non-baseline vertical-align property.
• Atomic content in the inline formatting context

Upon flushing, the ShapingQueue will shape any pending text and assign the resulting ShapedTextSlices to the originating TextRuns.

Fields

queue: Vec<ShapingQueueText>

The queue of items in the current batch that will be shaped together.

text: &'a str

The text that will be used for shaping.

line_breaker: LineBreaker

The line breaker that will be used to slice shaping results across on line break boundaries.

byte_range: Range<usize>

The byte range of the text to shape in Self::text for the current batch. Only contiguous ranges can be shaped together.

character_range: Range<usize>

The character range of the text to shape in Self::text for the current batch. Only contiguous ranges can be shaped together.

resolved_script: Option<Script>

The resolved script for the current batch. This is used to gradually turn non-specific scripts into a resolved value for shaping.

Implementations

impl<'a> ShapingQueue<'a>

pub(crate) fn new(text: &'a str, line_break_options: LineBreakOptions) -> Self

fn compatible_old_shaping_result( &self, character_count: usize, ) -> Option<Arc<ShapedText>>

fn shape_batch(&self) -> Option<Arc<ShapedText>>

pub(crate) fn flush(&mut self)

Flush this ShapingQueue. If any content had been collected up to this point, it will be shaped and the resulting ShapedTextSlices will be assigned to their originating TextRuns.

fn compatible_with_batch(&self, text: &ShapingQueueText) -> bool

fn push_text(&mut self, text: ShapingQueueText)

pub(crate) fn push(&mut self, entry: ShapingQueueEntry)

Push a new ShapingQueueEntry on to this ShapingQueue, maybe flushing previously collected entries.