Struct Grid

pub struct Grid<T> {
    pub cursor: Cursor<T>,
    pub saved_cursor: Cursor<T>,
    /* private fields */
}

Grid based terminal content storage.

┌─────────────────────────┐  <-- max_scroll_limit + lines
│                         │
│      UNINITIALIZED      │
│                         │
├─────────────────────────┤  <-- self.raw.inner.len()
│                         │
│      RESIZE BUFFER      │
│                         │
├─────────────────────────┤  <-- self.history_size() + lines
│                         │
│     SCROLLUP REGION     │
│                         │
├─────────────────────────┤v lines
│                         │|
│     VISIBLE  REGION     │|
│                         │|
├─────────────────────────┤^ <-- display_offset
│                         │
│    SCROLLDOWN REGION    │
│                         │
└─────────────────────────┘  <-- zero
                          ^
                       columns

Fields

cursor: Cursor<T>

Current cursor for writing data.

saved_cursor: Cursor<T>

Last saved cursor.

Implementations

impl<T: GridCell + Default + PartialEq> Grid<T>

pub fn resize<D>(&mut self, reflow: bool, lines: usize, columns: usize)

where T: ResetDiscriminant<D>, D: PartialEq,

Resize the grid’s width and/or height.

impl<T: GridCell + Default + PartialEq> Grid<T>

pub fn new(lines: usize, columns: usize, max_scroll_limit: usize) -> Grid<T>

pub fn update_history(&mut self, history_size: usize)

Update the size of the scrollback history.

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

pub fn scroll_down<D>(&mut self, region: &Range<Line>, positions: usize)

where T: ResetDiscriminant<D>, D: PartialEq,

pub fn scroll_up<D>(&mut self, region: &Range<Line>, positions: usize)

where T: ResetDiscriminant<D>, D: PartialEq,

Move lines at the bottom toward the top.

This is the performance-sensitive part of scrolling.

pub fn clear_viewport<D>(&mut self)

where T: ResetDiscriminant<D>, D: PartialEq,

pub fn reset<D>(&mut self)

where T: ResetDiscriminant<D>, D: PartialEq,

Completely reset the grid state.

impl<T> Grid<T>

pub fn reset_region<D, R: RangeBounds<Line>>(&mut self, bounds: R)

where T: ResetDiscriminant<D> + GridCell + Default, D: PartialEq,

Reset a visible region within the grid.

pub fn clear_history(&mut self)

pub fn initialize_all(&mut self)

where T: GridCell + Default,

This is used only for initializing after loading ref-tests.

pub fn truncate(&mut self)

This is used only for truncating before saving ref-tests.

pub fn iter_from(&self, point: Point) -> GridIterator<'_, T>

Iterate over all cells in the grid starting at a specific point.

pub fn display_iter(&self) -> GridIterator<'_, T>

Iterate over all visible cells.

This is slightly more optimized than calling Grid::iter_from in combination with Iterator::take_while.

pub fn display_offset(&self) -> usize

pub fn cursor_cell(&mut self) -> &mut T

Trait Implementations

impl<T: Clone> Clone for Grid<T>

fn clone(&self) -> Grid<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Grid<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Grid<T>

where T: Deserialize<'de> + Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G> Dimensions for Grid<G>

fn total_lines(&self) -> usize

Total number of lines in the buffer, this includes scrollback and visible lines.

fn screen_lines(&self) -> usize

Height of the viewport in lines.

fn columns(&self) -> usize

Width of the terminal in columns.

fn last_column(&self) -> Column

Index for the last column.

fn topmost_line(&self) -> Line

Line farthest up in the grid history.

fn bottommost_line(&self) -> Line

Line farthest down in the grid history.

fn history_size(&self) -> usize

Number of invisible lines part of the scrollback history.

impl<T> Index<Line> for Grid<T>

type Output = Row<T>

The returned type after indexing.

fn index(&self, index: Line) -> &Row<T>

Performs the indexing (container[index]) operation.

impl<T> Index<Point> for Grid<T>

type Output = T

The returned type after indexing.

fn index(&self, point: Point) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Line> for Grid<T>

fn index_mut(&mut self, index: Line) -> &mut Row<T>

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

impl<T> IndexMut<Point> for Grid<T>

fn index_mut(&mut self, point: Point) -> &mut T

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

impl<T: PartialEq> PartialEq for Grid<T>

fn eq(&self, other: &Self) -> 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<T> Serialize for Grid<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.