Struct Grid

pub struct Grid<T> {
    pub selection: Option<Selection>,
    /* private fields */
}

Represents the terminal display contents

┌─────────────────────────┐  <-- 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
                          ^
                         cols

Fields

selection: Option<Selection>

Selected region.

Implementations

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

pub fn new(lines: Line, cols: Column, scrollback: usize, template: T) -> Grid<T>

pub fn buffer_to_visible( &self, point: impl Into<Point<usize>>, ) -> Option<Point<usize>>

pub fn visible_to_buffer(&self, point: Point) -> Point<usize>

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 resize( &mut self, reflow: bool, lines: Line, cols: Column, cursor_pos: &mut Point, template: &T, )

pub fn line_to_offset(&self, line: Line) -> usize

Convert a Line index (active region) to a buffer offset

Panics

This method will panic if Line is larger than the grid dimensions

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

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

scroll_up moves lines at the bottom towards the top

This is the performance-sensitive part of scrolling.

pub fn clear_viewport(&mut self, template: &T)

pub fn reset(&mut self, template: &T)

impl<T> Grid<T>

pub fn num_lines(&self) -> Line

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

pub fn num_cols(&self) -> Column

pub fn clear_history(&mut self)

pub fn len(&self) -> usize

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

pub fn history_size(&self) -> usize

pub fn initialize_all(&mut self, template: &T)

where T: Copy + GridCell,

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<usize>) -> GridIterator<'_, T>

pub fn contains(&self, point: &Point) -> bool

pub fn display_offset(&self) -> usize

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>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'point, T> Index<&'point Point> for Grid<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

Index active region by line

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<usize> for Grid<T>

Index with buffer offset

type Output = Row<T>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'point, T> IndexMut<&'point Point> for Grid<T>

fn index_mut<'a, 'b>(&'a mut self, point: &'b Point) -> &'a mut T

Performs the mutable 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<usize> for Grid<T>

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

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

impl<T> IndexRegion<Range<Line>, T> for Grid<T>

fn region(&self, index: Range<Line>) -> Region<'_, T>

Get an immutable region of Self

fn region_mut(&mut self, index: Range<Line>) -> RegionMut<'_, T>

Get a mutable region of Self

impl<T> IndexRegion<RangeFrom<Line>, T> for Grid<T>

fn region(&self, index: RangeFrom<Line>) -> Region<'_, T>

Get an immutable region of Self

fn region_mut(&mut self, index: RangeFrom<Line>) -> RegionMut<'_, T>

Get a mutable region of Self

impl<T> IndexRegion<RangeFull, T> for Grid<T>

fn region(&self, _: RangeFull) -> Region<'_, T>

Get an immutable region of Self

fn region_mut(&mut self, _: RangeFull) -> RegionMut<'_, T>

Get a mutable region of Self

impl<T> IndexRegion<RangeTo<Line>, T> for Grid<T>

fn region(&self, index: RangeTo<Line>) -> Region<'_, T>

Get an immutable region of Self

fn region_mut(&mut self, index: RangeTo<Line>) -> RegionMut<'_, T>

Get a mutable region of Self

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.