Struct Span

Source

pub struct Span<'a> {
    pub style: Style,
    pub content: Cow<'a, str>,
}

Expand description

Represents a part of a line that is contiguous and where all characters share the same style.

A Span is the smallest unit of text that can be styled. It is usually combined in the Line type to represent a line of text where each Span may have a different style.

§Constructor Methods

Span::default creates an span with empty content and the default style.
Span::raw creates an span with the specified content and the default style.
Span::styled creates an span with the specified content and style.

§Setter Methods

These methods are fluent setters. They return a new Span with the specified property set.

Span::content sets the content of the span.
Span::style sets the style of the span.

§Other Methods

Span::patch_style patches the style of the span, adding modifiers from the given style.
Span::reset_style resets the style of the span.
Span::width returns the unicode width of the content held by this span.
Span::styled_graphemes returns an iterator over the graphemes held by this span.

§Examples

A Span with style set to Style::default() can be created from a &str, a String, or any type convertible to Cow<str>.

use ratatui::text::Span;

let span = Span::raw("test content");
let span = Span::raw(String::from("test content"));
let span = Span::from("test content");
let span = Span::from(String::from("test content"));
let span: Span = "test content".into();
let span: Span = String::from("test content").into();

Styled spans can be created using Span::styled or by converting strings using methods from the Stylize trait.

use ratatui::{
    style::{Style, Stylize},
    text::Span,
};

let span = Span::styled("test content", Style::new().green());
let span = Span::styled(String::from("test content"), Style::new().green());

// using Stylize trait shortcuts
let span = "test content".green();
let span = String::from("test content").green();

Span implements the Styled trait, which allows it to be styled using the shortcut methods defined in the Stylize trait.

use ratatui::{style::Stylize, text::Span};

let span = Span::raw("test content").green().on_yellow().italic();
let span = Span::raw(String::from("test content"))
    .green()
    .on_yellow()
    .italic();

Span implements the Widget trait, which allows it to be rendered to a Buffer. Usually apps will use the Paragraph widget instead of rendering Span directly, as it handles text wrapping and alignment for you.

use ratatui::{style::Stylize, Frame};

frame.render_widget("test content".green().on_yellow().italic(), frame.area());

Fields§

§style: Style

The style of the span.

§content: Cow<'a, str>

The content of the span as a Clone-on-write string.

Struct SpanCopy item path

§Constructor Methods

§Setter Methods

§Other Methods

§Examples

Fields§

Implementations§

impl<'a> Span<'a>

pub fn raw<T>(content: T) -> Selfwhere T: Into<Cow<'a, str>>,

§Examples

pub fn styled<T, S>(content: T, style: S) -> Selfwhere T: Into<Cow<'a, str>>, S: Into<Style>,

§Examples

pub fn content<T>(self, content: T) -> Selfwhere T: Into<Cow<'a, str>>,

§Examples

pub fn style<S: Into<Style>>(self, style: S) -> Self

§Examples

pub fn patch_style<S: Into<Style>>(self, style: S) -> Self

§Example

pub fn reset_style(self) -> Self

§Example

pub fn width(&self) -> usize

pub fn styled_graphemes<S: Into<Style>>( &'a self, base_style: S, ) -> impl Iterator<Item = StyledGrapheme<'a>>

§Example

pub fn into_left_aligned_line(self) -> Line<'a>

§Example

pub fn to_left_aligned_line(self) -> Line<'a>

pub fn into_centered_line(self) -> Line<'a>

§Example

pub fn to_centered_line(self) -> Line<'a>

pub fn into_right_aligned_line(self) -> Line<'a>

§Example

pub fn to_right_aligned_line(self) -> Line<'a>

Trait Implementations§

impl<'a> Add<Span<'a>> for Line<'a>

type Output = Line<'a>

fn add(self, rhs: Span<'a>) -> Self::Output

impl<'a> Add for Span<'a>

type Output = Line<'a>

fn add(self, rhs: Self) -> Self::Output

impl<'a> AddAssign<Span<'a>> for Line<'a>

fn add_assign(&mut self, rhs: Span<'a>)

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

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

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

impl Debug for Span<'_>

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

impl<'a> Default for Span<'a>

fn default() -> Span<'a>

impl Display for Span<'_>

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

impl<'a> Extend<Span<'a>> for Line<'a>

fn extend<T: IntoIterator<Item = Span<'a>>>(&mut self, iter: T)

fn extend_one(&mut self, item: A)

fn extend_reserve(&mut self, additional: usize)

impl<'a> From<Span<'a>> for Line<'a>

fn from(span: Span<'a>) -> Self

impl<'a> From<Span<'a>> for Text<'a>

fn from(span: Span<'a>) -> Self

impl<'a, T> From<T> for Span<'a>where T: Into<Cow<'a, str>>,

fn from(s: T) -> Self

impl<'a> Hash for Span<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl<'a> PartialEq for Span<'a>

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

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

impl<'a> Styled for Span<'a>

type Item = Span<'a>

fn style(&self) -> Style

fn set_style<S: Into<Style>>(self, style: S) -> Self::Item

impl Widget for Span<'_>

fn render(self, area: Rect, buf: &mut Buffer)

impl WidgetRef for Span<'_>

fn render_ref(&self, area: Rect, buf: &mut Buffer)

impl<'a> Eq for Span<'a>

impl<'a> StructuralPartialEq for Span<'a>

Auto Trait Implementations§

impl<'a> Freeze for Span<'a>

impl<'a> RefUnwindSafe for Span<'a>

impl<'a> Send for Span<'a>

Struct Span

pub fn raw<T>(content: T) -> Self
where T: Into<Cow<'a, str>>,

pub fn styled<T, S>(content: T, style: S) -> Self
where T: Into<Cow<'a, str>>, S: Into<Style>,

pub fn content<T>(self, content: T) -> Self
where T: Into<Cow<'a, str>>,

impl<'a, T> From<T> for Span<'a>
where T: Into<Cow<'a, str>>,

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S
where T: Real + Zero + Arithmetics + Clone, Swp: WhitePoint<T>, Dwp: WhitePoint<T>, D: AdaptFrom<S, Swp, Dwp, T>,

fn adapt_into_using<M>(self, method: M) -> D
where M: TransformMatrix<T>,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T, C> ArraysFrom<C> for T
where C: IntoArrays<T>,

impl<T, C> ArraysInto<C> for T
where C: FromArrays<T>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<WpParam, T, U> Cam16IntoUnclamped<WpParam, T> for U
where T: FromCam16Unclamped<WpParam, U>,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, C> ComponentsFrom<C> for T
where C: IntoComponents<T>,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<T, U> FromStimulus<U> for T
where U: IntoStimulus<T>,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T, U> IntoAngle<U> for T
where U: FromAngle<T>,

impl<WpParam, T, U> IntoCam16Unclamped<WpParam, T> for U
where T: Cam16FromUnclamped<WpParam, U>,

impl<T, U> IntoColor<U> for T
where U: FromColor<T>,

impl<T, U> IntoColorUnclamped<U> for T
where U: FromColorUnclamped<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<'a, T, U> Stylize<'a, T> for U
where U: Styled<Item = T>,

fn bg<C>(self, color: C) -> T
where C: Into<Color>,

fn fg<C>(self, color: C) -> T
where C: Into<Color>,