Struct StyledText 

pub struct StyledText {
    pub text: String,
    pub runs: Vec<TextRun>,
    pub paragraphs: Vec<ParagraphRun>,
}

A styled document: plain text, the character runs over it, and the paragraph attributes over the same offsets.

Fields

text: String

runs: Vec<TextRun>

paragraphs: Vec<ParagraphRun>

Implementations

impl StyledText

pub fn plain(text: impl Into<String>) -> StyledText

Unstyled text.

pub fn markdown(md: &str, base: Font) -> StyledText

Parse markdown, the ergonomic way to seed a document (styled_codec).

pub fn html(html: &str, base: Font) -> StyledText

Parse an HTML fragment.

pub fn rtf(rtf: &str, base: Font) -> StyledText

Parse the RTF subset Day reads (docs/texteditor.md).

pub fn to_markdown(&self, base: Font) -> String

Write this document as markdown / HTML / RTF. Each is lossy in the ways styled_codec documents.

pub fn to_html(&self, base: Font) -> String

pub fn to_rtf(&self, base: Font) -> String

pub fn new(text: impl Into<String>, runs: Vec<TextRun>) -> StyledText

Text with character runs and no paragraph attributes, which is what a label carries today.

pub fn is_empty(&self) -> bool

pub fn validate(&self) -> Result<(), String>

Are both range vectors well formed for the text (ascending, non-overlapping, in bounds, on character boundaries)?

pub fn segments(&self, base: Font) -> Vec<(Range<usize>, RunStyle)>

The whole text as consecutive (range, style) segments, unstyled gaps included as base.

One view that the query and the mutation below are both written against, so neither has to reason about where a run ends and a gap begins.

pub fn style_of(&self, range: Range<usize>, base: Font) -> RunStyle

The style in effect across range.

Where the segments under it disagree, the differing attribute comes back as its default rather than as one of the values. That is what a toolbar renders as its mixed state, and it is what makes pressing the button set the whole selection instead of toggling half of it.

A collapsed caret takes the style of the segment that ENDS at it, preferring that over the one it starts: typing after a bold word continues bold, which is what every editor does.

pub fn apply( &mut self, range: Range<usize>, base: Font, f: impl Fn(&mut RunStyle), )

Apply f to the style of every segment overlapping range, splitting at its boundaries so only the selected text changes, then coalescing what came out.

pub fn paragraph_style_of(&self, range: Range<usize>) -> ParagraphStyle

The paragraph style in effect across range, by the same mixed-state rule as StyledText::style_of.

pub fn apply_paragraph( &mut self, range: Range<usize>, f: impl Fn(&mut ParagraphStyle), )

Apply f to every paragraph the selection touches. Paragraph boundaries are \n, so a caret anywhere inside a paragraph styles the whole of it, which is what every editor does.

pub fn reflow(&mut self, offset: usize, removed: usize, inserted: usize)

Move the ranges over a character edit the native editor already made: removed bytes at offset replaced by inserted bytes.

This is why a keystroke does not have to ship the whole document back. Ranges before the edit are untouched, ranges after it shift, a range containing it grows or shrinks, and a range the edit emptied is dropped. That is the rule every attributed-string implementation uses, exact, and O(runs) rather than O(document).

self.text must already be the new text; this only moves ranges.

pub fn clamp(&mut self)

Clamp every range into the text and onto character boundaries, dropping what cannot be saved. The last defense before a range reaches a backend and panics an str slice.

pub fn splice(&mut self, range: Range<usize>, text: &str)

Replace range with text, moving every other range over the edit. The app-side twin of what a keystroke does, for a programmatic insert or delete.

Trait Implementations

impl Clone for StyledText

fn clone(&self) -> StyledText

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StyledText

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

Formats the value using the given formatter.

impl Default for StyledText

fn default() -> StyledText

Returns the “default value” for a type.

impl From<&str> for StyledText

fn from(text: &str) -> StyledText

Converts to this type from the input type.

impl From<String> for StyledText

fn from(text: String) -> StyledText

Converts to this type from the input type.

impl PartialEq for StyledText

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for StyledText