Struct meli::terminal::cells::CellBuffer

pub struct CellBuffer {
    cols: usize,
    rows: usize,
    buf: Vec<Cell>,
    pub default_cell: Cell,
    pub ascii_drawing: bool,
    growable: bool,
    tag_table: HashMap<u64, FormatTag>,
    tag_associations: SmallVec<[(u64, (usize, usize)); 128]>,
}

An array of Cells that represents a terminal display.

A CellBuffer is a two-dimensional array of Cells, each pair of indices correspond to a single point on the underlying terminal.

The first index, Cellbuffer[y], corresponds to a row, and thus the y-axis. The second index, Cellbuffer[y][x], corresponds to a column within a row and thus the x-axis.

Fields

cols: usize

rows: usize

buf: Vec<Cell>

default_cell: Cell

ascii_drawing: bool

ASCII-only flag.

growable: bool

If printing to this buffer and we run out of space, expand it.

tag_table: HashMap<u64, FormatTag>

tag_associations: SmallVec<[(u64, (usize, usize)); 128]>

Implementations

impl CellBuffer

pub fn area(&self) -> Area

pub fn set_cols(&mut self, new_cols: usize)

pub fn new(cols: usize, rows: usize, default_cell: Cell) -> CellBuffer

Constructs a new CellBuffer with the given number of columns and rows, using the given cell as a blank.

pub fn new_with_context(
    cols: usize,
    rows: usize,
    default_cell: Option<Cell>,
    context: &Context
) -> CellBuffer

pub fn set_ascii_drawing(&mut self, new_val: bool)

pub fn set_growable(&mut self, new_val: bool)

pub fn resize(&mut self, newcols: usize, newrows: usize, blank: Cell)

Resizes CellBuffer to the given number of rows and columns, using the given Cell as a blank.

pub fn is_empty(&self) -> bool

pub fn empty(&mut self)

pub fn clear(&mut self, blank: Cell)

Clears self, using the given Cell as a blank.

pub fn pos_to_index(&self, x: usize, y: usize) -> Option<usize>

pub fn get(&self, x: usize, y: usize) -> Option<&Cell>

Returns a reference to the Cell at the given coordinates, or None if the index is out of bounds.

Examples

let mut term = Terminal::new().unwrap();

let a_cell = term.get(5, 5);

pub fn get_mut(&mut self, x: usize, y: usize) -> Option<&mut Cell>

Returns a mutable reference to the Cell at the given coordinates, or None if the index is out of bounds.

Examples

let mut term = Terminal::new().unwrap();

let a_mut_cell = term.get_mut(5, 5);

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

pub fn cellvec(&self) -> &Vec<Cell>

pub fn cellvec_mut(&mut self) -> &mut Vec<Cell>

pub fn cols(&self) -> usize

pub fn rows(&self) -> usize

pub fn scroll_up(
    &mut self,
    scroll_region: &ScrollRegion,
    top: usize,
    offset: usize
)

Performs the normal scroll up motion:

First clear offset number of lines:

For offset = 1, top = 1:

| 111111111111 |            |              |
| 222222222222 |            | 222222222222 |
| 333333333333 |            | 333333333333 |
| 444444444444 |    -->     | 444444444444 |
| 555555555555 |            | 555555555555 |
| 666666666666 |            | 666666666666 |

In each step, swap the current line with the next by offset:

|              |            | 222222222222 |
| 222222222222 |            |              |
| 333333333333 |            | 333333333333 |
| 444444444444 |    -->     | 444444444444 |
| 555555555555 |            | 555555555555 |
| 666666666666 |            | 666666666666 |

Result:

  Before                      After
| 111111111111 |            | 222222222222 |
| 222222222222 |            | 333333333333 |
| 333333333333 |            | 444444444444 |
| 444444444444 |            | 555555555555 |
| 555555555555 |            | 666666666666 |
| 666666666666 |            |              |

pub fn scroll_down(
    &mut self,
    scroll_region: &ScrollRegion,
    top: usize,
    offset: usize
)

Performs the normal scroll down motion:

First clear offset number of lines:

For offset = 1, top = 1:

| 111111111111 |            | 111111111111 |
| 222222222222 |            | 222222222222 |
| 333333333333 |            | 333333333333 |
| 444444444444 |    -->     | 444444444444 |
| 555555555555 |            | 555555555555 |
| 666666666666 |            |              |

In each step, swap the current line with the prev by offset:

| 111111111111 |            | 111111111111 |
| 222222222222 |            | 222222222222 |
| 333333333333 |            | 333333333333 |
| 444444444444 |    -->     | 444444444444 |
| 555555555555 |            |              |
|              |            | 555555555555 |

Result:

  Before                      After
| 111111111111 |            |              |
| 222222222222 |            | 111111111111 |
| 333333333333 |            | 222222222222 |
| 444444444444 |            | 333333333333 |
| 555555555555 |            | 444444444444 |
| 666666666666 |            | 555555555555 |

pub fn bounds_iter(&self, area: Area) -> BoundsIterator

See BoundsIterator documentation.

pub fn row_iter(&self, bounds: Range<usize>, row: usize) -> RowIterator

See RowIterator documentation.

pub fn tag_associations(&self) -> SmallVec<[(usize, u64, bool); 128]>

pub fn tag_table(&self) -> &HashMap<u64, FormatTag>

pub fn tag_table_mut(&mut self) -> &mut HashMap<u64, FormatTag>

pub fn insert_tag(&mut self, tag: FormatTag) -> u64

pub fn set_tag(&mut self, tag: u64, start: (usize, usize), end: (usize, usize))

Trait Implementations

impl Clone for CellBuffer

fn clone(&self) -> CellBuffer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CellBuffer

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

Formats the value using the given formatter.

impl Default for CellBuffer

fn default() -> CellBuffer

Constructs a new CellBuffer with a size of (0, 0), using the default Cell as a blank.

impl Deref for CellBuffer

type Target = [Cell]

The resulting type after dereferencing.

fn deref(&self) -> &[Cell]

Dereferences the value.

impl DerefMut for CellBuffer

fn deref_mut(&mut self) -> &mut [Cell]

Mutably dereferences the value.

impl Display for CellBuffer

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

Formats the value using the given formatter.

impl Eq for CellBuffer

impl Index<(usize, usize)> for CellBuffer

type Output = Cell

The returned type after indexing.

fn index(&self, index: Pos) -> &Cell

Performs the indexing (container[index]) operation.

impl IndexMut<(usize, usize)> for CellBuffer

fn index_mut(&mut self, index: Pos) -> &mut Cell

Performs the mutable indexing (container[index]) operation.

impl KMP for CellBuffer

fn kmp_search(&self, pattern: &str) -> SmallVec<[usize; 256]>

fn kmp_table(graphemes: &[&str]) -> SmallVec<[i32; 256]>

impl PartialEq<CellBuffer> for CellBuffer

fn eq(&self, other: &CellBuffer) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for CellBuffer

impl StructuralPartialEq for CellBuffer