Struct cosmic::iced_runtime::core::text::Span

pub struct Span<'a, Link = (), Font = Font> {
    pub text: Cow<'a, str>,
    pub size: Option<Pixels>,
    pub line_height: Option<LineHeight>,
    pub font: Option<Font>,
    pub color: Option<Color>,
    pub link: Option<Link>,
    pub highlight: Option<Highlight>,
    pub padding: Padding,
    pub underline: bool,
    pub strikethrough: bool,
}

A span of text.

Fields

text: Cow<'a, str>

The Fragment of text.

size: Option<Pixels>

The size of the Span in Pixels.

line_height: Option<LineHeight>

The LineHeight of the Span.

font: Option<Font>

The font of the Span.

color: Option<Color>

The Color of the Span.

link: Option<Link>

The link of the Span.

highlight: Option<Highlight>

The Highlight of the Span.

padding: Padding

The Padding of the Span.

Currently, it only affects the bounds of the Highlight.

underline: bool

Whether the Span should be underlined or not.

strikethrough: bool

Whether the Span should be struck through or not.

Implementations

impl<'a, Link, Font> Span<'a, Link, Font>

pub fn new(fragment: impl IntoFragment<'a>) -> Span<'a, Link, Font>

Creates a new Span of text with the given text fragment.

pub fn size(self, size: impl Into<Pixels>) -> Span<'a, Link, Font>

Sets the size of the Span.

pub fn line_height( self, line_height: impl Into<LineHeight>, ) -> Span<'a, Link, Font>

Sets the LineHeight of the Span.

pub fn font(self, font: impl Into<Font>) -> Span<'a, Link, Font>

Sets the font of the Span.

pub fn font_maybe(self, font: Option<impl Into<Font>>) -> Span<'a, Link, Font>

Sets the font of the Span, if any.

pub fn color(self, color: impl Into<Color>) -> Span<'a, Link, Font>

Sets the Color of the Span.

pub fn color_maybe( self, color: Option<impl Into<Color>>, ) -> Span<'a, Link, Font>

Sets the Color of the Span, if any.

pub fn link(self, link: impl Into<Link>) -> Span<'a, Link, Font>

Sets the link of the Span.

pub fn link_maybe(self, link: Option<impl Into<Link>>) -> Span<'a, Link, Font>

Sets the link of the Span, if any.

pub fn background( self, background: impl Into<Background>, ) -> Span<'a, Link, Font>

Sets the Background of the Span.

pub fn background_maybe( self, background: Option<impl Into<Background>>, ) -> Span<'a, Link, Font>

Sets the Background of the Span, if any.

pub fn border(self, border: impl Into<Border>) -> Span<'a, Link, Font>

Sets the Border of the Span.

pub fn border_maybe( self, border: Option<impl Into<Border>>, ) -> Span<'a, Link, Font>

Sets the Border of the Span, if any.

pub fn padding(self, padding: impl Into<Padding>) -> Span<'a, Link, Font>

Sets the Padding of the Span.

It only affects the background and border of the Span, currently.

pub fn underline(self, underline: bool) -> Span<'a, Link, Font>

Sets whether the Span should be underlined or not.

pub fn strikethrough(self, strikethrough: bool) -> Span<'a, Link, Font>

Sets whether the Span should be struck through or not.

pub fn to_static(self) -> Span<'static, Link, Font>

Turns the Span into a static one.

Trait Implementations

impl<'a, Link, Font> Clone for Span<'a, Link, Font>

where Link: Clone, Font: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Link, Font> Debug for Span<'a, Link, Font>

where Link: Debug, Font: Debug,

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

Formats the value using the given formatter.

impl<'a, Link, Font> From<&'a str> for Span<'a, Link, Font>

fn from(value: &'a str) -> Span<'a, Link, Font>

Converts to this type from the input type.

impl<'a, Link, Theme, Renderer> FromIterator<Span<'a, Link, <Renderer as Renderer>::Font>> for Rich<'a, Link, Theme, Renderer>

where Link: Clone + 'a, Theme: Catalog, Renderer: Renderer, <Renderer as Renderer>::Font: 'a,

fn from_iter<T>(spans: T) -> Rich<'a, Link, Theme, Renderer>

where T: IntoIterator<Item = Span<'a, Link, <Renderer as Renderer>::Font>>,

Creates a value from an iterator.

impl<'a, Link, Font> PartialEq for Span<'a, Link, Font>

where Font: PartialEq,

fn eq(&self, other: &Span<'a, Link, Font>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.