Struct Buffer

pub struct Buffer {
    pub area: Rect,
    pub content: Vec<Cell>,
}

Fields

area: Rect

The area represented by this buffer

content: Vec<Cell>

The content of the buffer. The length of this Vec should always be equal to area.width * area.height

Implementations

impl Buffer

pub fn empty(area: Rect) -> Self

Returns a Buffer with all cells set to the default one

pub fn filled(area: Rect, cell: Cell) -> Self

Returns a Buffer with all cells initialized with the attributes of the given Cell

pub fn content(&self) -> &[Cell]

Returns the content of the buffer as a slice

pub const fn area(&self) -> &Rect

Returns the area covered by this buffer

pub fn get(&self, x: u16, y: u16) -> &Cell

Returns a reference to Cell at the given coordinates

pub fn get_mut(&mut self, x: u16, y: u16) -> &mut Cell

Returns a mutable reference to Cell at the given coordinates

pub fn index_of(&self, x: u16, y: u16) -> usize

Returns the index in the Vec<Cell> for the given global (x, y) coordinates.

Global coordinates are offset by the Buffer’s area offset (x/y).

Panics

Panics when given an coordinate that is outside of this Buffer’s area.

pub fn pos_of(&self, i: usize) -> (u16, u16)

Returns the (global) coordinates of a cell given its index

Global coordinates are offset by the Buffer’s area offset (x/y).

Panics

Panics when given an index that is outside the Buffer’s content.

pub fn set_string<T, S>(&mut self, x: u16, y: u16, string: T, style: S)

where T: AsRef<str>, S: Into<Style>,

Print a string, starting at the position (x, y)

pub fn set_stringn<T, S>( &mut self, x: u16, y: u16, string: T, max_width: usize, style: S, ) -> (u16, u16)

where T: AsRef<str>, S: Into<Style>,

Print at most the first n characters of a string if enough space is available until the end of the line.

Use Buffer::set_string when the maximum amount of characters can be printed.

pub fn set_style<S: Into<Style>>(&mut self, area: Rect, style: S)

Set the style of all cells in the given area.

style accepts any type that is convertible to Style (e.g. Style, Color, or your own type that implements Into<Style>).

pub fn resize(&mut self, area: Rect)

Resize the buffer so that the mapped area matches the given area and that the buffer length is equal to area.width * area.height

pub fn reset(&mut self)

Reset all cells in the buffer

pub fn merge(&mut self, other: &Self)

Merge an other buffer into this one

pub fn diff<'a>(&self, other: &'a Self) -> Vec<(u16, u16, &'a Cell)>

Builds a minimal sequence of coordinates and Cells necessary to update the UI from self to other.

We’re assuming that buffers are well-formed, that is no double-width cell is followed by a non-blank cell.

Multi-width characters handling:

(Index:) `01`
Prev:    `コ`
Next:    `aa`
Updates: `0: a, 1: a'

(Index:) `01`
Prev:    `a `
Next:    `コ`
Updates: `0: コ` (double width symbol at index 0 - skip index 1)

(Index:) `012`
Prev:    `aaa`
Next:    `aコ`
Updates: `0: a, 1: コ` (double width symbol at index 1 - skip index 2)

Trait Implementations

impl Clone for Buffer

fn clone(&self) -> Buffer

Returns a copy 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

Writes a debug representation of the buffer to the given formatter.

The format is like a pretty printed struct, with the following fields:

• area: displayed as Rect { x: 1, y: 2, width: 3, height: 4 }
• content: displayed as a list of strings representing the content of the buffer
• styles: displayed as a list of: { x: 1, y: 2, fg: Color::Red, bg: Color::Blue, modifier: Modifier::BOLD } only showing a value when there is a change in style.

impl Default for Buffer

fn default() -> Buffer

Returns the “default value” for a type.

impl Hash for Buffer

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Buffer

fn eq(&self, other: &Buffer) -> 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.

impl Eq for Buffer

impl StructuralPartialEq for Buffer