Struct Cell 

pub struct Cell {
    pub ch: char,
    pub colors: ColorPair,
    pub bold: bool,
    pub dim: bool,
    pub italic: bool,
    pub underline: bool,
}

A styled terminal cell.

Fields

ch: char

colors: ColorPair

bold: bool

dim: bool

italic: bool

underline: bool

Implementations

impl Cell

pub fn new(ch: char) -> Self

Examples found in repository

examples/loaders.rs (line 346)

fn colored_cell(ch: char, fg: Color, bg: Option<Color>, bold: bool, dim: bool) -> Cell {
    let mut cell = Cell::new(ch);
    cell.colors.fg = Some(fg);
    cell.colors.bg = bg;
    cell.bold = bold;
    cell.dim = dim;
    cell
}

examples/new_loaders.rs (line 193)

fn colored_cell(ch: char, fg: Color, bg: Option<Color>, bold: bool, dim: bool) -> Cell {
    let mut cell = Cell::new(ch);
    cell.colors.fg = Some(fg);
    cell.colors.bg = bg;
    cell.bold = bold;
    cell.dim = dim;
    cell
}

examples/loader_lab.rs (line 966)

fn fill_rect(screen: &mut Frame, area: Rect, bg: Option<Color>) {
    for y in area.y..(area.y + area.h).min(screen.height()) {
        for x in area.x..(area.x + area.w).min(screen.width()) {
            let mut cell = Cell::new(' ');
            cell.colors.bg = bg;
            screen.set(x, y, cell);
        }
    }
}

fn draw_frame(screen: &mut Frame, x: usize, y: usize, frame: &Frame, max_w: usize, max_h: usize) {
    for fy in 0..frame.height().min(max_h) {
        for fx in 0..frame.width().min(max_w) {
            if let Some(cell) = frame.cell(fx, fy) {
                if cell.ch != ' ' || cell.has_style() {
                    screen.set(x + fx, y + fy, cell.clone());
                }
            }
        }
    }
}

fn put_text(
    screen: &mut Frame,
    x: usize,
    y: usize,
    text: &str,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    put_text_clipped(screen, x, y, text, usize::MAX, fg, bg, bold);
}

fn put_text_clipped(
    screen: &mut Frame,
    x: usize,
    y: usize,
    text: &str,
    max_width: usize,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    if y >= screen.height() || max_width == 0 {
        return;
    }
    for (offset, ch) in text.chars().take(max_width).enumerate() {
        let px = x + offset;
        if px >= screen.width() {
            break;
        }
        put_cell(screen, px, y, ch, fg, bg, bold, false);
    }
}

fn put_text_right(
    screen: &mut Frame,
    right_x: usize,
    y: usize,
    text: &str,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    let x = right_x.saturating_sub(text.chars().count());
    put_text(screen, x, y, text, fg, bg, bold);
}

fn put_cell(
    screen: &mut Frame,
    x: usize,
    y: usize,
    ch: char,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
    dim: bool,
) {
    if x >= screen.width() || y >= screen.height() {
        return;
    }
    let mut cell = Cell::new(ch);
    cell.colors.fg = Some(fg);
    cell.colors.bg = bg;
    cell.bold = bold;
    cell.dim = dim;
    screen.set(x, y, cell);
}

examples/story.rs (line 856)

fn fill_rect(screen: &mut Frame, area: Rect, bg: Option<Color>) {
    for y in area.y..(area.y + area.h).min(screen.height()) {
        for x in area.x..(area.x + area.w).min(screen.width()) {
            let mut cell = Cell::new(' ');
            cell.colors.bg = bg;
            screen.set(x, y, cell);
        }
    }
}

fn draw_quote(screen: &mut Frame, area: Rect, quote: &str, accent: Color) {
    let wrapped = wrap_text(quote, area.w);
    put_text(
        screen,
        area.x,
        area.y,
        "SOURCE FROM test.sh:",
        accent,
        Some(Color::rgb(7, 12, 18)),
        true,
    );
    for (line_index, line) in wrapped.lines().take(area.h.saturating_sub(1)).enumerate() {
        put_text(
            screen,
            area.x,
            area.y + line_index + 1,
            line,
            Color::rgb(186, 204, 214),
            Some(Color::rgb(7, 12, 18)),
            false,
        );
    }
}

fn draw_frame_centered(screen: &mut Frame, area: Rect, frame: &Frame) {
    let x = area.x + area.w.saturating_sub(frame.width()) / 2;
    let y = area.y + area.h.saturating_sub(frame.height()) / 2;
    draw_frame(screen, x, y, frame, area.w, area.h);
}

fn draw_frame(screen: &mut Frame, x: usize, y: usize, frame: &Frame, max_w: usize, max_h: usize) {
    for fy in 0..frame.height().min(max_h) {
        for fx in 0..frame.width().min(max_w) {
            if let Some(cell) = frame.cell(fx, fy) {
                if cell.ch != ' ' || cell.has_style() {
                    screen.set(x + fx, y + fy, cell.clone());
                }
            }
        }
    }
}

fn draw_progress_strip(screen: &mut Frame, area: Rect, ratio: f32, fill: Color, empty: Color) {
    let active = (ratio.clamp(0.0, 1.0) * area.w as f32).round() as usize;
    for x in 0..area.w {
        let done = x < active;
        put_cell(
            screen,
            area.x + x,
            area.y,
            if done { '#' } else { '-' },
            if done { fill } else { empty },
            Some(Color::rgb(7, 12, 18)),
            done,
            !done,
        );
    }
}

fn put_text(
    screen: &mut Frame,
    x: usize,
    y: usize,
    text: &str,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    if y >= screen.height() {
        return;
    }
    for (offset, ch) in text.chars().enumerate() {
        let px = x + offset;
        if px >= screen.width() {
            break;
        }
        put_cell(screen, px, y, ch, fg, bg, bold, false);
    }
}

fn put_text_right(
    screen: &mut Frame,
    right_x: usize,
    y: usize,
    text: &str,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
) {
    let width = text.chars().count();
    let x = right_x.saturating_sub(width);
    put_text(screen, x, y, text, fg, bg, bold);
}

fn put_cell(
    screen: &mut Frame,
    x: usize,
    y: usize,
    ch: char,
    fg: Color,
    bg: Option<Color>,
    bold: bool,
    dim: bool,
) {
    if x >= screen.width() || y >= screen.height() {
        return;
    }
    let mut cell = Cell::new(ch);
    cell.colors.fg = Some(fg);
    cell.colors.bg = bg;
    cell.bold = bold;
    cell.dim = dim;
    screen.set(x, y, cell);
}

pub fn styled( ch: char, fg: impl Into<Option<Color>>, bg: impl Into<Option<Color>>, ) -> Self

pub fn with_fg(self, color: Color) -> Self

pub fn with_bg(self, color: Color) -> Self

pub fn has_style(&self) -> bool

Examples found in repository

examples/loader_lab.rs (line 977)

fn draw_frame(screen: &mut Frame, x: usize, y: usize, frame: &Frame, max_w: usize, max_h: usize) {
    for fy in 0..frame.height().min(max_h) {
        for fx in 0..frame.width().min(max_w) {
            if let Some(cell) = frame.cell(fx, fy) {
                if cell.ch != ' ' || cell.has_style() {
                    screen.set(x + fx, y + fy, cell.clone());
                }
            }
        }
    }
}

examples/story.rs (line 897)

fn draw_frame(screen: &mut Frame, x: usize, y: usize, frame: &Frame, max_w: usize, max_h: usize) {
    for fy in 0..frame.height().min(max_h) {
        for fx in 0..frame.width().min(max_w) {
            if let Some(cell) = frame.cell(fx, fy) {
                if cell.ch != ' ' || cell.has_style() {
                    screen.set(x + fx, y + fy, cell.clone());
                }
            }
        }
    }
}

examples/new_loaders.rs (line 164)

fn overlay_frame(screen: &mut Frame, x0: usize, y0: usize, src: &Frame) {
    for y in 0..src.height() {
        for x in 0..src.width() {
            if let Some(cell) = src.cell(x, y) {
                if cell.ch == ' ' && !cell.has_style() {
                    continue;
                }
                if x + x0 < screen.width() && y + y0 < screen.height() {
                    screen.set(x + x0, y + y0, cell.clone());
                }
            }
        }
    }
}

examples/loaders.rs (line 312)

fn draw_card(
    screen: &mut Frame,
    layout: &GridLayout,
    x: usize,
    y: usize,
    width: usize,
    height: usize,
    kind: LoaderKind,
    frame: &Frame,
) {
    if width == 0 || height == 0 {
        return;
    }
    let pane_bg = Color::rgb(9, 14, 22);
    let border = Color::rgb(48, 72, 96);
    let title = loader_title_color(kind);
    for py in 0..height {
        for px in 0..width {
            screen.set(
                x + px,
                y + py,
                colored_cell(' ', Color::rgb(40, 48, 56), Some(pane_bg), false, false),
            );
        }
    }
    if height >= 3 && width >= 8 {
        for px in 0..width {
            screen.set(
                x + px,
                y,
                colored_cell('-', border, Some(pane_bg), false, true),
            );
        }
        screen.set(x, y, colored_cell('+', border, Some(pane_bg), false, false));
        screen.set(
            x + width - 1,
            y,
            colored_cell('+', border, Some(pane_bg), false, false),
        );
        put_text(screen, x + 2, y, kind.name(), title, true);
    } else {
        put_text(screen, x, y, kind.name(), title, true);
    }
    if height == 1 {
        return;
    }

    let inner_y = y + 1;
    let inner_x = if width > 2 { x + 1 } else { x };
    let inner_width = width.saturating_sub(2).max(1);
    let inner_height = height.saturating_sub(1).max(1);
    for fy in 0..frame.height().min(inner_height) {
        for fx in 0..frame.width().min(inner_width) {
            if let Some(cell) = frame.cell(fx, fy) {
                if cell.ch != ' ' || cell.has_style() {
                    screen.set(inner_x + fx, inner_y + fy, cell.clone());
                }
            }
        }
    }

    if layout.card_height <= 2 && width > 8 {
        let percent_x = x + width.saturating_sub(5);
        put_text(
            screen,
            percent_x,
            y,
            "    ",
            Color::rgb(120, 132, 144),
            false,
        );
    }
}

Trait Implementations

impl Clone for Cell

fn clone(&self) -> Cell

Returns a duplicate 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() -> Self

Returns the “default value” for a type.

impl Eq for Cell

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 StructuralPartialEq for Cell