Struct MatrixDisplay

pub struct MatrixDisplay<'a, T>
where
    T: Clone + ToString + 'a,
{ /* private fields */ }

Stores a matrix of data and offers a way to pretty print it

#Example: visualising a 256 colors palette:

use matrix_display::*;
let format = Format::new(5,1);
let board = (0..256)
       .map(|x| cell::Cell::new(x, 0, x as u8))
    .collect::<Vec<_>>();
let mut data = matrix::Matrix::new(8, board);
let display = MatrixDisplay::new(&format, &mut data);
display.print(&mut std::io::stdout(), &style::BordersStyle::Light);

Implementations

impl<'a, T> MatrixDisplay<'a, T>

where T: Clone + ToString + 'a,

pub fn new(f: &'a Format, m: &'a mut Matrix<Cell<T>>) -> MatrixDisplay<'a, T>

Construct a matrix display

f: the format of a cell (width, height) m: a reference to the data (&Matrix)

Examples found in repository

examples/palette.rs (line 10)

fn main() {
    let format = Format::new(5, 1);
    let board = (0..256)
        .map(|x| cell::Cell::new(x, 0, x as u8))
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(8, board);
    let display = MatrixDisplay::new(&format, &mut data);
    display.print(&mut std::io::stdout(), &style::BordersStyle::Light);
}

examples/2048.rs (line 19)

fn main() {
    let format = Format::new(7, 3);
    let colour_theme = vec![
        247, 78, 222, 220, 214, 208, 202, 196, 162, 160, 126, 90, 88, 54, 53, 52,
    ];
    let board = (0..16)
        .map(|x| {
            cell::Cell::new(
                2_f64.powi(x + 1),
                7,
                *colour_theme.get(x as usize).unwrap() as u8,
            )
        })
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(4, board);
    let display = MatrixDisplay::new(&format, &mut data);
    display.print(&mut std::io::stdout(), &style::BordersStyle::Heavy);
}

examples/chess.rs (line 27)

fn main() {
    let format = Format::new(7, 3);
    #[cfg_attr(rustfmt, rustfmt_skip)]
    let board = vec!['♜', '♞', '♝', '♛', '♚', '♝', '♞', '♜',
	                 '♟', '♟', '♟', '♟', '♟', '♟', '♟', '♟',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                     ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 '♖', '♘', '♗', '♕', '♔', '♗', '♘', '♖',
					 '♙', '♙', '♙', '♙', '♙', '♙', '♙', '♙']
        .iter()
        .enumerate()
        .map(|(i, x)| {
            let ansi_fg = 33;
            let mut ansi_bg = 0;
            if i % 2 + (i / 8) % 2 == 1 {
                ansi_bg = 7;
            }
            cell::Cell::new(x.clone(), ansi_fg, ansi_bg)
        })
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(8, board);
    let mut display = MatrixDisplay::new(&format, &mut data);
    display.cell_at_cursor_position((13, 6)).color.bg = 10;
    display.print(&mut std::io::stdout(), &style::BordersStyle::None);
}

pub fn width(&self) -> usize

The matrix’s width in number of characters

pub fn height(&self) -> usize

The matrix’s height in number of characters

pub fn render(&self, borders: &BordersStyle) -> Vec<ANSIString<'static>>

Render a matrix into a Vec.

Pick a BorderStyle, an output that implements the Write trait and you’re good to go! This approach allows the user to customize how to display the matrix.

pub fn print<Out: Write>(&self, out: &mut Out, borders: &BordersStyle)

Print a matrix. This is the most important method of this library

Pick a BorderStyle, an output that implements the Write trait and you’re good to go!

Examples found in repository

examples/palette.rs (line 11)

fn main() {
    let format = Format::new(5, 1);
    let board = (0..256)
        .map(|x| cell::Cell::new(x, 0, x as u8))
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(8, board);
    let display = MatrixDisplay::new(&format, &mut data);
    display.print(&mut std::io::stdout(), &style::BordersStyle::Light);
}

examples/2048.rs (line 20)

fn main() {
    let format = Format::new(7, 3);
    let colour_theme = vec![
        247, 78, 222, 220, 214, 208, 202, 196, 162, 160, 126, 90, 88, 54, 53, 52,
    ];
    let board = (0..16)
        .map(|x| {
            cell::Cell::new(
                2_f64.powi(x + 1),
                7,
                *colour_theme.get(x as usize).unwrap() as u8,
            )
        })
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(4, board);
    let display = MatrixDisplay::new(&format, &mut data);
    display.print(&mut std::io::stdout(), &style::BordersStyle::Heavy);
}

examples/chess.rs (line 29)

fn main() {
    let format = Format::new(7, 3);
    #[cfg_attr(rustfmt, rustfmt_skip)]
    let board = vec!['♜', '♞', '♝', '♛', '♚', '♝', '♞', '♜',
	                 '♟', '♟', '♟', '♟', '♟', '♟', '♟', '♟',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                     ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 '♖', '♘', '♗', '♕', '♔', '♗', '♘', '♖',
					 '♙', '♙', '♙', '♙', '♙', '♙', '♙', '♙']
        .iter()
        .enumerate()
        .map(|(i, x)| {
            let ansi_fg = 33;
            let mut ansi_bg = 0;
            if i % 2 + (i / 8) % 2 == 1 {
                ansi_bg = 7;
            }
            cell::Cell::new(x.clone(), ansi_fg, ansi_bg)
        })
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(8, board);
    let mut display = MatrixDisplay::new(&format, &mut data);
    display.cell_at_cursor_position((13, 6)).color.bg = 10;
    display.print(&mut std::io::stdout(), &style::BordersStyle::None);
}

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

Takes a cursor position in (usize, usize) and returns the coordinates of the cell under the cursor

pub fn cell_at_cursor_position( &mut self, cursor: (usize, usize), ) -> &mut Cell<T>

Takes a cursor position in characters (x, y) and returns a mutable reference to the corresponding cell

This is used to modify a cell that was clicked

Examples found in repository

examples/chess.rs (line 28)

fn main() {
    let format = Format::new(7, 3);
    #[cfg_attr(rustfmt, rustfmt_skip)]
    let board = vec!['♜', '♞', '♝', '♛', '♚', '♝', '♞', '♜',
	                 '♟', '♟', '♟', '♟', '♟', '♟', '♟', '♟',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                     ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
					 '♖', '♘', '♗', '♕', '♔', '♗', '♘', '♖',
					 '♙', '♙', '♙', '♙', '♙', '♙', '♙', '♙']
        .iter()
        .enumerate()
        .map(|(i, x)| {
            let ansi_fg = 33;
            let mut ansi_bg = 0;
            if i % 2 + (i / 8) % 2 == 1 {
                ansi_bg = 7;
            }
            cell::Cell::new(x.clone(), ansi_fg, ansi_bg)
        })
        .collect::<Vec<_>>();
    let mut data = matrix::Matrix::new(8, board);
    let mut display = MatrixDisplay::new(&format, &mut data);
    display.cell_at_cursor_position((13, 6)).color.bg = 10;
    display.print(&mut std::io::stdout(), &style::BordersStyle::None);
}