Struct Cell

pub struct Cell { /* private fields */ }

A single point on a terminal display.

A Cell contains a character and style.

Implementations

impl Cell

pub fn new(ch: char, fg: Color, bg: Color, attrs: Attr) -> Cell

Creates a new Cell with the given char, Colors and Attr.

Examples

use rustty::{Cell, Color, Attr};

let cell = Cell::new('x', Color::Default, Color::Green, Attr::Default);
assert_eq!(cell.ch(), 'x');
assert_eq!(cell.fg(), Color::Default);
assert_eq!(cell.bg(), Color::Green);
assert_eq!(cell.attrs(), Attr::Default);

pub fn with_char(ch: char) -> Cell

Creates a new Cell with the given char and default style.

Examples

use rustty::{Cell, Color, Attr};

let mut cell = Cell::with_char('x');
assert_eq!(cell.ch(), 'x');
assert_eq!(cell.fg(), Color::Default);
assert_eq!(cell.bg(), Color::Default);
assert_eq!(cell.attrs(), Attr::Default);

pub fn with_style(fg: Color, bg: Color, attr: Attr) -> Cell

Creates a new Cell with the given style and a blank char.

Examples

use rustty::{Cell, Color, Attr};

let mut cell = Cell::with_style(Color::Default, Color::Red, Attr::Bold);
assert_eq!(cell.fg(), Color::Default);
assert_eq!(cell.bg(), Color::Red);
assert_eq!(cell.attrs(), Attr::Bold);
assert_eq!(cell.ch(), ' ');

pub fn ch(&self) -> char

Returns the Cell’s character.

Examples

use rustty::Cell;

let mut cell = Cell::with_char('x');
assert_eq!(cell.ch(), 'x');

pub fn set_ch(&mut self, newch: char) -> &mut Cell

Sets the Cell’s character to the given char

Examples

use rustty::Cell;

let mut cell = Cell::with_char('x');
assert_eq!(cell.ch(), 'x');

cell.set_ch('y');
assert_eq!(cell.ch(), 'y');

Examples found in repository

examples/circle.rs (line 60)

fn main() {
    // Create our terminal, dialog window and main canvas
    let mut term = Terminal::new().unwrap();
    let mut optiondlg = create_optiondlg();
    let mut canvas = Widget::new(term.size().0, term.size().1 - 4);

    // Align canvas to top left, and dialog to bottom right
    optiondlg.window_mut().align(&term, HorizontalAlign::Right, VerticalAlign::Bottom, 0);
    canvas.align(&term, HorizontalAlign::Left, VerticalAlign::Top, 0);

    let mut radius = 10u32;
    'main: loop {
        while let Some(Event::Key(ch)) = term.get_event(Duration::new(0, 0)).unwrap() {
            match ch {
                'q' => break 'main,
                '+' => radius = radius.saturating_add(1),
                '-' => radius = radius.saturating_sub(1),
                _ => {}
            }
        }
        // Grab the size of the canvas
        let (cols, rows) = canvas.size();
        let (cols, rows) = (cols as isize, rows as isize);

        let (a, b) = (cols / 2, rows / 2);

        // Main render loop, draws the circle to canvas
        for i in 0..cols * rows {
            let y = i as isize / cols;
            let x = i as isize % cols;

            let mut cell = canvas.get_mut(x as usize, y as usize).unwrap();

            if ((x - a).pow(2) / 4 + (y - b).pow(2)) <= radius.pow(2) as isize {
                cell.set_ch(BLOCK);
            } else {
                cell.set_ch(' ');
            }
        }

        // draw the canvas, dialog window and swap buffers
        canvas.draw_into(&mut term);
        optiondlg.window().draw_into(&mut term);
        term.swap_buffers().unwrap();
    }
}

examples/textedit.rs (line 42)

fn main() {
    let mut cursor = Cursor {
        pos: Position { x: 0, y: 0 },
        lpos: Position { x: 0, y: 0 },
        color: Color::Red,
    };
    let mut term = Terminal::new().unwrap();
    term[(cursor.pos.x, cursor.pos.y)].set_bg(cursor.color);
    term.swap_buffers().unwrap();
    loop {
        let evt = term.get_event(Duration::from_millis(100)).unwrap();
        if let Some(Event::Key(ch)) = evt {
            match ch {
                '`' => {
                    break;
                }
                '\x7f' => {
                    cursor.lpos = cursor.pos;
                    if cursor.pos.x == 0 {
                        cursor.pos.y = cursor.pos.y.saturating_sub(1);
                    } else {
                        cursor.pos.x -= 1;
                    }
                    term[(cursor.pos.x, cursor.pos.y)].set_ch(' ');
                }
                '\r' => {
                    cursor.lpos = cursor.pos;
                    cursor.pos.x = 0;
                    cursor.pos.y += 1;
                }
                c @ _ => {
                    term[(cursor.pos.x, cursor.pos.y)].set_ch(c);
                    cursor.lpos = cursor.pos;
                    cursor.pos.x += 1;
                }
            }
            if cursor.pos.x >= term.cols() - 1 {
                term[(cursor.lpos.x, cursor.lpos.y)].set_bg(Color::Default);
                cursor.lpos = cursor.pos;
                cursor.pos.x = 0;
                cursor.pos.y += 1;
            }
            if cursor.pos.y >= term.rows() - 1 {
                term[(cursor.lpos.x, cursor.lpos.y)].set_bg(Color::Default);
                cursor.lpos = cursor.pos;
                cursor.pos.x = 0;
                cursor.pos.y = 0;
            }
            term[(cursor.lpos.x, cursor.lpos.y)].set_bg(Color::Default);
            term[(cursor.pos.x, cursor.pos.y)].set_bg(cursor.color);
            term.swap_buffers().unwrap();
        }
    }
}

pub fn fg(&self) -> Color

Returns the Cell’s foreground Color.

Examples

use rustty::{Cell, Color, Attr};

let mut cell = Cell::with_style(Color::Blue, Color::Default, Attr::Default);
assert_eq!(cell.fg(), Color::Blue);

pub fn set_fg(&mut self, newfg: Color) -> &mut Cell

Sets the Cell’s foreground Color to the given Color.

Examples

use rustty::{Cell, Color, Attr};

let mut cell = Cell::default();
assert_eq!(cell.fg(), Color::Default);

cell.set_fg(Color::White);
assert_eq!(cell.fg(), Color::White);

pub fn bg(&self) -> Color

Returns the Cell’s background Color.

Examples

use rustty::{Cell, Color, Attr};

let mut cell = Cell::with_style(Color::Default, Color::Green, Attr::Default);
assert_eq!(cell.bg(), Color::Green);

pub fn set_bg(&mut self, newbg: Color) -> &mut Cell

Sets the Cell’s background Color to the given Color.

Examples

use rustty::{Cell, Color, Attr};

let mut cell = Cell::default();
assert_eq!(cell.bg(), Color::Default);

cell.set_bg(Color::Black);
assert_eq!(cell.bg(), Color::Black);

Examples found in repository

examples/textedit.rs (line 26)

fn main() {
    let mut cursor = Cursor {
        pos: Position { x: 0, y: 0 },
        lpos: Position { x: 0, y: 0 },
        color: Color::Red,
    };
    let mut term = Terminal::new().unwrap();
    term[(cursor.pos.x, cursor.pos.y)].set_bg(cursor.color);
    term.swap_buffers().unwrap();
    loop {
        let evt = term.get_event(Duration::from_millis(100)).unwrap();
        if let Some(Event::Key(ch)) = evt {
            match ch {
                '`' => {
                    break;
                }
                '\x7f' => {
                    cursor.lpos = cursor.pos;
                    if cursor.pos.x == 0 {
                        cursor.pos.y = cursor.pos.y.saturating_sub(1);
                    } else {
                        cursor.pos.x -= 1;
                    }
                    term[(cursor.pos.x, cursor.pos.y)].set_ch(' ');
                }
                '\r' => {
                    cursor.lpos = cursor.pos;
                    cursor.pos.x = 0;
                    cursor.pos.y += 1;
                }
                c @ _ => {
                    term[(cursor.pos.x, cursor.pos.y)].set_ch(c);
                    cursor.lpos = cursor.pos;
                    cursor.pos.x += 1;
                }
            }
            if cursor.pos.x >= term.cols() - 1 {
                term[(cursor.lpos.x, cursor.lpos.y)].set_bg(Color::Default);
                cursor.lpos = cursor.pos;
                cursor.pos.x = 0;
                cursor.pos.y += 1;
            }
            if cursor.pos.y >= term.rows() - 1 {
                term[(cursor.lpos.x, cursor.lpos.y)].set_bg(Color::Default);
                cursor.lpos = cursor.pos;
                cursor.pos.x = 0;
                cursor.pos.y = 0;
            }
            term[(cursor.lpos.x, cursor.lpos.y)].set_bg(Color::Default);
            term[(cursor.pos.x, cursor.pos.y)].set_bg(cursor.color);
            term.swap_buffers().unwrap();
        }
    }
}

pub fn attrs(&self) -> Attr

pub fn set_attrs(&mut self, newattrs: Attr) -> &mut Cell

Trait Implementations

impl Clone for Cell

fn clone(&self) -> Cell

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cell

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

Formats the value using the given formatter.

impl Default for Cell

fn default() -> Cell

Constructs a new Cell with a blank char and default Colors.

Examples

use rustty::{Cell, Color};

let mut cell = Cell::default();
assert_eq!(cell.ch(), ' ');
assert_eq!(cell.fg(), Color::Default);
assert_eq!(cell.bg(), Color::Default);

impl PartialEq for Cell

fn eq(&self, other: &Cell) -> 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 Copy for Cell

impl Eq for Cell

impl StructuralPartialEq for Cell