Struct cosmic_text::BorrowedWithFontSystem

pub struct BorrowedWithFontSystem<'a, T> { /* private fields */ }

A value borrowed together with an FontSystem

Implementations

impl<'a> BorrowedWithFontSystem<'a, Buffer>

pub fn shape_until_cursor(&mut self, cursor: Cursor, prune: bool)

Shape lines until cursor, also scrolling to include cursor in view

pub fn shape_until_scroll(&mut self, prune: bool)

Shape lines until scroll

pub fn line_shape(&mut self, line_i: usize) -> Option<&ShapeLine>

Shape the provided line index and return the result

pub fn line_layout(&mut self, line_i: usize) -> Option<&[LayoutLine]>

Lay out the provided line index and return the result

pub fn set_metrics(&mut self, metrics: Metrics)

Set the current Metrics

Panics

Will panic if metrics.font_size is zero.

pub fn set_wrap(&mut self, wrap: Wrap)

Set the current Wrap

pub fn set_size(&mut self, width: f32, height: f32)

Set the current buffer dimensions

pub fn set_metrics_and_size( &mut self, metrics: Metrics, width: f32, height: f32 )

Set the current Metrics and buffer dimensions at the same time

Panics

Will panic if metrics.font_size is zero.

pub fn set_text(&mut self, text: &str, attrs: Attrs<'_>, shaping: Shaping)

Set text of buffer, using provided attributes for each line by default

pub fn set_rich_text<'r, 's, I>( &mut self, spans: I, default_attrs: Attrs<'_>, shaping: Shaping )

where I: IntoIterator<Item = (&'s str, Attrs<'r>)>,

Set text of buffer, using an iterator of styled spans (pairs of text and attributes)

let mut buffer = Buffer::new_empty(Metrics::new(32.0, 44.0));
let mut buffer = buffer.borrow_with(&mut font_system);
let attrs = Attrs::new().family(Family::Serif);
buffer.set_rich_text(
    [
        ("hello, ", attrs),
        ("cosmic\ntext", attrs.family(Family::Monospace)),
    ],
    attrs,
    Shaping::Advanced,
);

pub fn cursor_motion( &mut self, cursor: Cursor, cursor_x_opt: Option<i32>, motion: Motion ) -> Option<(Cursor, Option<i32>)>

Apply a Motion to a Cursor

pub fn draw<F>(&mut self, cache: &mut SwashCache, color: Color, f: F)

where F: FnMut(i32, i32, u32, u32, Color),

Draw the buffer

impl<'font_system, 'buffer> BorrowedWithFontSystem<'font_system, Editor<'buffer>>

pub fn draw<F>( &mut self, cache: &mut SwashCache, text_color: Color, cursor_color: Color, selection_color: Color, f: F )

where F: FnMut(i32, i32, u32, u32, Color),

impl<'font_system, 'buffer, E: Edit<'buffer>> BorrowedWithFontSystem<'font_system, E>

pub fn with_buffer_mut<F: FnOnce(&mut BorrowedWithFontSystem<'_, Buffer>) -> T, T>( &mut self, f: F ) -> T

Get the internal Buffer, mutably

pub fn shape_as_needed(&mut self, prune: bool)

Shape lines until scroll, after adjusting scroll if the cursor moved

pub fn action(&mut self, action: Action)

Perform an Action on the editor

Trait Implementations

impl<'a, T: Debug> Debug for BorrowedWithFontSystem<'a, T>

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

Formats the value using the given formatter.

impl<'a, T> Deref for BorrowedWithFontSystem<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T> DerefMut for BorrowedWithFontSystem<'a, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.