Struct RenderedText 

pub struct RenderedText { /* private fields */ }

A snapshot of the text a TextViewState renders, as of one parse of its content.

Offsets into it are UTF-8 byte offsets. It is the string plain copy produces: hello **world** renders as hello world, escapes are resolved, and heading markers and list markers are left out. Blocks end with a newline and table cells are joined with a space; those separators belong to no block, so no highlight paints them.

Two snapshots are equal when they come from the same view and the same parse. Comparing the current rendered_text with the one last searched tells an observer of the view whether its content changed, so setting highlights, which notifies the view too, does not start another search. The text itself is only built when it is first read, from the parsed document the snapshot holds on to, so drop a snapshot that is no longer needed rather than keeping it past many changes.

Implementations

impl RenderedText

pub fn as_str(&self) -> &str

The rendered text.

pub fn len(&self) -> usize

The length of the rendered text, in bytes.

pub fn is_empty(&self) -> bool

Whether the view renders no text.

pub fn source(&self) -> &str

The source this text was rendered from, whose byte ranges range_for_source takes.

It comes from the same parse as the text, so it trails the text last given to the view until that text’s parse lands. Before converting a range, check that it indexes this source: while text is streamed in, this source is a prefix of the text the application holds, and after set_text it may be different text.

pub fn range_for_source(&self, source: Range<usize>) -> Option<Range<usize>>

The range of this text rendered from source, a UTF-8 byte range of Self::source.

This converts a range of the Markdown source, such as one selected_source_range returned or one an application stored with its own data, into the range a RangeHighlight takes. A character is rendered from source when any of the source it was rendered from lies in it: all of & for &, the \ and the * of \*, the whole source of an inline object for its text. Source that renders nothing, such as emphasis delimiters, heading and list markers, code fences, table pipes and link destinations, adds nothing, so **bold** and bold give the same range.

The result is the smallest range holding every character rendered from source. When source spans blocks, it also holds the separators between them, which a highlight leaves unpainted. Text the parser recorded no source position for, such as the text of inline HTML, is only included when it lies between characters that are.

Converting the source range a selection of this text reports gives the selected range back, widened only to whole characters where several share their source, like the text of an inline object. The separators between blocks are rendered from no source, so one at either end of the selection is left out: Select All gives back everything but the line break after the last block.

Returns None when source is empty, reversed, out of bounds, or not on a character boundary, or when nothing is rendered from it. HTML views record no source positions, so they always return None.

Trait Implementations

impl Clone for RenderedText

fn clone(&self) -> RenderedText

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RenderedText

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

Formats the value using the given formatter.

impl Eq for RenderedText

impl PartialEq for RenderedText

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

Equality operator ==.

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

Inequality operator !=.