Struct Buffer

pub struct Buffer {
    pub lines: Vec<BufferLine>,
    /* private fields */
}

A buffer of text that is shaped and laid out

Fields

lines: Vec<BufferLine>

BufferLines (or paragraphs) of text in the buffer

Implementations

impl Buffer

pub fn new_empty(metrics: Metrics) -> Buffer

Create an empty Buffer with the provided Metrics. This is useful for initializing a Buffer without a FontSystem.

You must populate the Buffer with at least one BufferLine before shaping and layout, for example by calling Buffer::set_text.

If you have a FontSystem in scope, you should use Buffer::new instead.

Panics

Will panic if metrics.line_height is zero.

pub fn new(font_system: &mut FontSystem, metrics: Metrics) -> Buffer

Create a new Buffer with the provided FontSystem and Metrics

Panics

Will panic if metrics.line_height is zero.

pub fn borrow_with<'a>( &'a mut self, font_system: &'a mut FontSystem, ) -> BorrowedWithFontSystem<'a, Buffer>

Mutably borrows the buffer together with an FontSystem for more convenient methods

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

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

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

Shape lines until scroll, resolving any pending dirty state first.

This processes dirty flags (invalidating caches for lines that need reshaping or relayout) and then shapes/layouts visible lines.

Call this before reading layout results via layout_runs or hit when working with the Buffer directly. The BorrowedWithFontSystem wrapper calls this automatically.

pub fn layout_cursor( &mut self, font_system: &mut FontSystem, cursor: Cursor, ) -> Option<LayoutCursor>

Convert a Cursor to a LayoutCursor

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

Shape the provided line index and return the result

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

Lay out the provided line index and return the result

pub const fn metrics(&self) -> Metrics

Get the current Metrics

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

Set the current Metrics.

Panics

Will panic if metrics.font_size is zero.

pub const fn hinting(&self) -> Hinting

Get the current Hinting strategy.

pub fn set_hinting(&mut self, hinting: Hinting)

Set the current Hinting strategy.

pub const fn wrap(&self) -> Wrap

Get the current Wrap

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

Set the current Wrap.

pub const fn ellipsize(&self) -> Ellipsize

Get the current Ellipsize

pub fn set_ellipsize(&mut self, ellipsize: Ellipsize)

Set the current Ellipsize.

pub const fn monospace_width(&self) -> Option<f32>

Get the current monospace_width

pub fn set_monospace_width(&mut self, monospace_width: Option<f32>)

Set monospace width monospace glyphs should be resized to match. None means don’t resize.

pub const fn tab_width(&self) -> u16

Get the current tab_width

pub fn set_tab_width(&mut self, tab_width: u16)

Set tab width (number of spaces between tab stops).

pub const fn size(&self) -> (Option<f32>, Option<f32>)

Get the current buffer dimensions (width, height)

pub fn set_size(&mut self, width_opt: Option<f32>, height_opt: Option<f32>)

Set the current buffer dimensions.

pub fn set_metrics_and_size( &mut self, metrics: Metrics, width_opt: Option<f32>, height_opt: Option<f32>, )

Set the current Metrics and buffer dimensions at the same time.

Panics

Will panic if metrics.font_size is zero.

pub const fn scroll(&self) -> Scroll

Get the current scroll location

pub fn set_scroll(&mut self, scroll: Scroll)

Set the current scroll location

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

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, alignment: Option<Align>, )

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 attrs = Attrs::new().family(Family::Serif);
buffer.set_rich_text(
    [
        ("hello, ", attrs.clone()),
        ("cosmic\ntext", attrs.clone().family(Family::Monospace)),
    ],
    &attrs,
    Shaping::Advanced,
    None,
);

pub const fn redraw(&self) -> bool

True if a redraw is needed

pub fn set_redraw(&mut self, redraw: bool)

Set redraw needed flag

pub fn layout_runs(&self) -> LayoutRunIter<'_>

Get the visible layout runs for rendering and other tasks.

This returns an iterator over the laid-out runs that are visible in the current scroll region. Call shape_until_scroll first to ensure the buffer is up to date, or use BorrowedWithFontSystem which calls it automatically.

pub fn hit(&self, x: f32, y: f32) -> Option<Cursor>

Convert x, y position to Cursor (hit detection).

Call shape_until_scroll first to ensure the buffer is up to date, or use BorrowedWithFontSystem which calls it automatically.

pub fn cursor_position(&self, cursor: &Cursor) -> Option<(f32, f32)>

Returns the visual (x, y) position of a cursor within the buffer. y is the top of the line containing the cursor. This is a convenience wrapper around LayoutRun::cursor_position.

pub fn is_rtl(&self, line: usize) -> Option<bool>

Returns if the text direction for a given line is RTL Returns None if the line doesn’t exist or hasn’t been shaped yet.

pub fn cursor_motion( &mut self, font_system: &mut FontSystem, 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, font_system: &mut FontSystem, cache: &mut SwashCache, color: Color, callback: F, )

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

Draw the buffer.

Automatically resolves any pending dirty state before drawing.

pub fn render<R>( &mut self, font_system: &mut FontSystem, renderer: &mut R, color: Color, )

where R: Renderer,

Render the buffer using the provided renderer.

Automatically resolves any pending dirty state before rendering.

Trait Implementations

impl Clone for Buffer

fn clone(&self) -> Buffer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Buffer

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

Formats the value using the given formatter.

impl<'buffer> From<&'buffer mut Buffer> for BufferRef<'buffer>

fn from(buffer: &'buffer mut Buffer) -> BufferRef<'buffer>

Converts to this type from the input type.

impl From<Buffer> for BufferRef<'_>

fn from(buffer: Buffer) -> BufferRef<'_>

Converts to this type from the input type.