Struct cosmic_text::Buffer

pub struct Buffer<'a> {
    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<'a> Buffer<'a>

pub fn new(font_system: &'a FontSystem, metrics: Metrics) -> Self

Create a new Buffer with the provided FontSystem and Metrics

pub fn shape_until(&mut self, lines: i32) -> i32

Pre-shape lines in the buffer, up to lines, return actual number of layout lines

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

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

pub fn shape_until_scroll(&mut self)

Shape lines until scroll

pub fn layout_cursor(&self, cursor: &Cursor) -> LayoutCursor

pub fn font_system(&self) -> &'a FontSystem

Get FontSystem used by this Buffer

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 metrics(&self) -> Metrics

Get the current Metrics

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

Set the current Metrics

pub fn size(&self) -> (i32, i32)

Get the current buffer dimensions (width, height)

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

Set the current buffer dimensions

pub fn scroll(&self) -> i32

Get the current scroll location

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

Set the current scroll location

pub fn visible_lines(&self) -> i32

Get the number of lines that can be viewed in the buffer

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

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

pub 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<'b>(&'b self) -> LayoutRunIter<'a, 'b>

Get the visible layout runs for rendering and other tasks

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

Convert x, y position to Cursor (hit detection)

pub fn draw<F>(&self, cache: &mut SwashCache<'_>, color: Color, f: F)where
    F: FnMut(i32, i32, u32, u32, Color),

Draw the buffer