Struct Span 

pub struct Span<'a> {
    pub text: &'a str,
    pub color: Option<Color>,
    pub bold: bool,
    pub italic: bool,
    pub underline: bool,
    pub underline_color: Option<Color>,
    pub underline_style: UnderlineStyle,
    pub strikethrough: bool,
    pub bg: Option<Color>,
    pub bg_radius: f32,
    pub family: Option<FontFamily>,
    pub size: Option<f32>,
}

One styled run inside a rich-text paragraph. Spans are shaped and wrapped together as a single flow; plain data, so every frontend can build them.

Fields

text: &'a str

color: Option<Color>

bold: bool

italic: bool

underline: bool

A line under the span, where the face puts its underline.

underline_color: Option<Color>

The underline’s own colour; None is the span’s.

underline_style: UnderlineStyle

The underline’s shape.

strikethrough: bool

A line through the span, where the face puts its strikeout.

bg: Option<Color>

A background behind the span’s glyphs, one rect per line it spans, so it follows the span across a wrap the way a box cannot.

bg_radius: f32

The background’s corner radius, logical px. Above zero, every background of the same colour and radius that meets another edge to edge on the line above or below — in this text or another — is one shape with it: its corners convex where a line reaches past its neighbour, concave where it falls short, round where nothing meets it. What a selection over lines looks like.

family: Option<FontFamily>

The span’s own face, in place of the paragraph’s: inline code in FontFamily::Mono inside a sans line. None is the paragraph’s. The span keeps the paragraph’s weights for its family (bold is the family’s bold), and its glyphs, carets and selection are measured in the face they are drawn in, so byte positions stay exact across the change.

size: Option<f32>

The span’s own size in logical px, in place of the paragraph’s: a heading’s larger first word, a smaller footnote mark. Its line height scales with it at the paragraph’s ratio, and a line is as tall as its tallest span. None is the paragraph’s. A paragraph with a sized span is shaped whole, never chunked as a long line.

Implementations

impl<'a> Span<'a>

pub fn new(text: &'a str) -> Span<'a>

pub fn family(self, family: FontFamily) -> Span<'a>

The span in its own face (see the family field).

pub fn mono(self) -> Span<'a>

The span in the monospace face: inline code.

let code = Span::new("cargo test").mono();
assert_eq!(code.family, Some(FontFamily::Mono));

pub fn size(self, px: f32) -> Span<'a>

The span at its own size in logical px (see the size field); a size that is not a positive number is the paragraph’s.

pub fn color(self, c: Color) -> Span<'a>

pub fn bold(self) -> Span<'a>

pub fn italic(self) -> Span<'a>

pub fn underline(self) -> Span<'a>

pub fn underline_color(self, c: Color) -> Span<'a>

An underline in its own colour; turns it on.

pub fn underline_style(self, s: UnderlineStyle) -> Span<'a>

An underline of this shape; turns it on.

pub fn strikethrough(self) -> Span<'a>

pub fn bg(self, c: Color) -> Span<'a>

pub fn bg_radius(self, r: f32) -> Span<'a>

Rounds the background, joined with the ones it meets (see Span::bg_radius).

Trait Implementations

impl<'a> Clone for Span<'a>

fn clone(&self) -> Span<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Span<'a>

impl<'a> Debug for Span<'a>

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

Formats the value using the given formatter.