Struct Region 

pub struct Region<'a> { /* private fields */ }

A temporary view of a logical region of a Page that allows writing text

The region is logical in the sense that it may be partly or fully outside of the actual boundaries of the page, or of any region it was derived from. All data written is only written if it is within the clip. The clip is the smallest of the page, the region and all the parent regions. However on writing, the logical write position is advanced as if the characters were written in any case.

This acts like a mini terminal in that it remembers its current hfb colour and write position, and lets you change them, and write text to the ‘terminal’. Text will character-wrap at the region’s logical right boundary back to the region’s logical left boundary. This also implements the Write trait so it can be used for formatted output with write!(region, ...).

However note that the region doesn’t scroll like a real terminal when you reach the bottom. (It can’t since the page doesn’t necessarily store the whole region’s contents.)

Any sequences of the form \0ZZZ written to the region represent an HFB colour and change the current HFB colour. Generate one of these sequences using a string escape sequence (e.g. "\0099" to set default fg/bg), or else by using the HFB type which allows encoding any 16-bit HFB value.

Implementations

impl Region<'_>

pub fn full(&mut self) -> Region<'_>

Generate a child region the same size as this one. This is like a clone of the region except that it borrows from the parent region whilst it exists.

Examples found in repository

examples/fontedit/app.rs (line 233)

    fn draw_mini(&mut self, cx: CX![]) {
        if let Some(mut full) = self.mini_tile.full(cx) {
            full.clear_all_99();
            let sx = full.sx() * 2;
            let sy = full.sy() * 4;
            let font_sx = self.font.sx as i32;
            let font_sy = self.font.sy as i32;
            let oy = sy.saturating_sub(font_sy) / 2;
            let mut ox = (sx - font_sx) / 2;
            let mut index = self.index;
            while ox > 0 && index > 0 {
                ox -= font_sx;
                index -= 1;
            }
            while ox < sx {
                draw_mini_cell(&self.font, full.full(), oy, ox, index, 170);
                ox += font_sx;
                index += 1;
            }
        }
    }

pub fn region(&mut self, y: i32, x: i32, sy: i32, sx: i32) -> Region<'_>

Generate a child region that may be any size, inside or outside this region. When drawn to, only the part of the child region that overlaps this region (and all its parent regions) will be affected.

Examples found in repository

examples/teeclub/draw.rs (line 10)

pub fn card(r: &mut Region, y: i32, x: i32, card: Card) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(card.hfb).clear_all();
    r.at(0, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
    r.at(CARD_SY - 1, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
}

/// Draw the back of a card
pub fn card_back(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(27);
    for y in 0..CARD_SY {
        r.at(y, 0).text("||||||");
    }
}

/// Draw the space where a card could go
pub fn card_space(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(71).clear_all();
}

/// Draw "more cards" indicator
pub fn card_dots(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(70);
    for y in 0..CARD_SY {
        r.at(y, 0).text("::::::");
    }
}

examples/fontedit/app.rs (line 137)

    fn draw_param(&mut self, cx: CX![]) {
        if let Some(mut r) = self.param_tile.full(cx) {
            r.hfb(172).clear_all();

            // Use sub-region to clip the filename if it's too long
            r.region(0, 0, 1, 39)
                .hfb(172)
                .text("File:  ")
                .text(&self.font.path.to_string_lossy());

            let count = self.font.index_limit();
            let index = self.index;

            let state = if let Some(ref err) = self.save_error {
                err
            } else if self.unsaved {
                "UNSAVED"
            } else {
                ""
            };
            let cp = self.font.chars[index].cp;
            let ch = match cp {
                32..=126 | 160.. => char::from_u32(cp).unwrap_or('?'),
                _ => '?',
            };
            let sx = self.font.sx;
            let sy = self.font.sy;

            r.at(1, 0);
            let _ = writeln!(r, "Size:  {sx} x {sy}, {count} glyphs");
            let _ = writeln!(r, "Index: {index} U+{cp:04x} '{ch}'");
            let _ = writeln!(r, "Mode:  {}", self.mode.caps());
            let _ = writeln!(r, "State: {}", state);
        }
    }

    fn draw_cells(&mut self, cx: CX![]) {
        if let Some(mut full) = self.cells_tile.full(cx) {
            let sx = full.sx();
            full.clear_all_99();

            let font_sx = self.font.sx;
            let font_sy = self.font.sy;
            let cell_wid = font_sx * 2;
            let r = full.region(
                0,
                (sx - cell_wid as i32) / 2,
                font_sy as i32,
                cell_wid as i32,
            );
            draw_cell(
                &self.font,
                r,
                self.index,
                171,
                7,
                Some((self.cy, self.cx, self.mode)),
            );
            let max = self.font.index_limit();
            for i in 1..=self.index {
                let r = full.region(
                    0,
                    (sx - (cell_wid * (1 + i * 2)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index - i, 70, 6, None);
            }
            for i in 1..(max - self.index) {
                let r = full.region(
                    0,
                    (sx + (cell_wid * (i * 2 - 1)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index + i, 70, 6, None);
            }
        }
    }

pub fn region_inplace(&mut self, y: i32, x: i32, sy: i32, sx: i32)

Replace this region with a child region that may be any size, inside or outside the old region. When drawn to, only the part of the new region that overlaps the old region (and all its parent regions) will be affected.

pub fn sizer(&self) -> Sizer

Get the active Sizer

pub fn size(&self) -> (i32, i32)

Get the region size

pub fn sy(&self) -> i32

Get the region size-Y, i.e. rows

Examples found in repository

examples/fontedit/app.rs (line 222)

    fn draw_mini(&mut self, cx: CX![]) {
        if let Some(mut full) = self.mini_tile.full(cx) {
            full.clear_all_99();
            let sx = full.sx() * 2;
            let sy = full.sy() * 4;
            let font_sx = self.font.sx as i32;
            let font_sy = self.font.sy as i32;
            let oy = sy.saturating_sub(font_sy) / 2;
            let mut ox = (sx - font_sx) / 2;
            let mut index = self.index;
            while ox > 0 && index > 0 {
                ox -= font_sx;
                index -= 1;
            }
            while ox < sx {
                draw_mini_cell(&self.font, full.full(), oy, ox, index, 170);
                ox += font_sx;
                index += 1;
            }
        }
    }

examples/teeclub/main.rs (line 179)

    fn draw_scores(&mut self, cx: CX![]) {
        let mut score = self.score;
        let mut last_score = self.last_score;
        if let Some(mut r) = self.scores_tile.full(cx) {
            r.hfb(176).clear_all();
            r.hfb(7).text("SCORES");
            let mut y = 1;
            let last_y = r.sy() - 1;
            let mut draw = move |hfb, sc| {
                if y > 0 {
                    r.at(y, 0).hfb(hfb);
                    write!(r, "{:3}:{:02}", sc / 60, sc % 60).unwrap();
                    y += 1;
                }
            };

            for &s0 in &self.scores {
                if let Some(curr) = score
                    && (curr < s0 || y == last_y)
                {
                    draw(7, curr);
                    score = None;
                }
                if Some(s0) == last_score {
                    draw(173, s0);
                    last_score = None;
                } else {
                    draw(176, s0);
                }
            }
            if let Some(s1) = score {
                draw(173, s1);
            }
        }
    }

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

    fn draw_instructions(mut r: Region<'_>) {
        const TEXT: &str = r"

        Keys: [N] New game; [Q] Quit; [1] to [9] Select cards in
        corresponding column; [+]/[=] or [-] Increase or decrease
        number of selected cards; [1] to [9] If the same digit as the
        selecting keypress, move selected cards to top, if another
        digit, move as many of selected cards as possible to that
        column; [Space] Bring a new card down from the stock pile;
        [BackSp] Go back one move; [<]/[>] Adjust display left/right.

        Rules: The aim is to move all the cards to the top area, the
        spaces the the right of the stock pile.  Each top pile must
        consist of one suit only, stacked in order from Ace up to
        King.  The cards in the main area can be moved around:
        sequences of one or more cards of the same suit may be moved
        on top of a card with the next-higher number, of any suit.
        The bulk of the cards are in the stock pile in the top-left.
        Cards may be brought down from there using Space.

        ";
        let lines: Vec<_> = TEXT.trim().split('\n').map(|s| s.to_string()).collect();
        let n_lines = lines.len();
        let oy = (r.sy() - n_lines as i32) / 2;
        for (i, line) in lines.iter().enumerate() {
            r.at(i as i32 + oy, 7);
            let line = line.trim().replace("[", "\0171 ").replace("]", " \0099");
            r.text(&line);
        }
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Pr('q' | 'Q') => {
                if self.game.is_some() {
                    self.game = None;
                    self.score = None;
                    self.layout(cx);
                } else {
                    stop!(cx);
                }
            }
            Key::Pr('n' | 'N') => {
                self.game = Some(Game::new(
                    cx.now(),
                    ret_some_to!([cx], game_finished() as (Duration)),
                ));
                self.last_score = None;
                self.update_score(cx);
                self.layout(cx);
            }
            Key::Pr('<') => {
                self.adjust -= 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            Key::Pr('>') => {
                self.adjust += 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            _ => {
                if let Some(game) = &mut self.game {
                    game.input(cx, key);
                }
            }
        }
    }

    fn update_score(&mut self, cx: CX![]) {
        if let Some(game) = &mut self.game {
            let dur = game.score(cx);
            let score = dur.as_secs() as i32;
            let to_wait = if Some(score) != self.score {
                self.score = Some(score);
                self.draw_scores(cx);

                // Update 100ms after next change
                1_000_000_000 - dur.subsec_nanos() + 100_000_000
            } else {
                1_000_000_000
            };
            after!(Duration::from_nanos(to_wait as u64), [cx], update_score());
        }
    }

    fn game_finished(&mut self, cx: CX![], dur: Duration) {
        let score = dur.as_secs() as i32;
        self.scores.push(score);
        self.scores.sort_unstable();
        self.save_scores().expect("Failed to save scores");
        self.last_score = Some(score);
        self.score = None;
        self.game = None;
        self.layout(cx);
    }

    fn score_path() -> PathBuf {
        let mut path = std::env::home_dir().unwrap_or_default();
        path.push(".teeclub-scores");
        path
    }

    fn load_scores(&mut self) -> Option<()> {
        let data = std::fs::read_to_string(Self::score_path()).ok()?;
        let mut it = data.split(char::is_whitespace);
        while let Some(tok) = it.next() {
            match tok {
                "adjust:" => {
                    self.adjust = it.next()?.parse::<i32>().ok()?;
                }
                "scores[" => {
                    self.scores = Vec::new();
                    loop {
                        match it.next()? {
                            "]" => break,
                            v => self.scores.push(v.parse::<i32>().ok()?),
                        }
                    }
                    self.scores.sort_unstable();
                }
                "" => (),
                _ => return None,
            }
        }
        Some(())
    }

    fn save_scores(&mut self) -> std::io::Result<()> {
        let mut out = Vec::new();
        let _ = writeln!(out, "adjust: {}", self.adjust);
        let _ = writeln!(out, "scores[");
        for sc in self.scores.iter().take(200) {
            let _ = writeln!(out, "{sc}");
        }
        let _ = writeln!(out, "]");
        std::fs::write(Self::score_path(), out)
    }
}

/// Game state
#[derive(Eq, PartialEq)]
struct State {
    pile: [Hand; 9],
    stack: [Hand; 9],
}

impl State {
    fn pack(&self) -> Vec<u8> {
        let mut out = Vec::new();
        for p in &self.pile {
            p.pack(&mut out);
        }
        for s in &self.stack {
            s.pack(&mut out);
        }
        out
    }

    fn unpack(mut data: &[u8]) -> Self {
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();
        for p in &mut pile {
            *p = Hand::unpack(&mut data);
        }
        for s in &mut stack {
            *s = Hand::unpack(&mut data);
        }
        Self { pile, stack }
    }
}

/// Game state and gameplay handling
struct Game {
    tile: Tile,
    history: Vec<Vec<u8>>,
    state: State,
    select: Option<(usize, usize)>, // (index, count)
    dur: Duration,
    activity: Instant,
    ret: Option<Ret<Duration>>, // Report score for game completion
}

impl Game {
    fn new(start: Instant, ret: Ret<Duration>) -> Self {
        let seed = std::time::SystemTime::UNIX_EPOCH
            .elapsed()
            .map(|d| d.as_nanos() as u64)
            .unwrap_or(0);

        let mut rand = Rand32::new(seed);
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();

        let p0 = &mut pile[0];
        p0.add_deck();
        p0.add_deck();
        p0.shuffle(&mut rand);
        p0.shuffle(&mut rand);

        for _ in 0..5 {
            for s in &mut stack {
                if let Some(card) = p0.pick_last() {
                    s.add(card);
                }
            }
        }

        Self {
            tile: Tile::default(),
            history: Vec::new(),
            state: State { pile, stack },
            select: None,
            dur: Duration::from_secs(0),
            activity: start,
            ret: Some(ret),
        }
    }

    fn select(&mut self, core: &mut Core, i: usize) {
        let s = &self.state.stack[i];
        let len = s.len();
        if len == 0 {
            self.select = None;
        } else {
            let mut count = 1;
            while count < len && s[len - count].inc == Some(s[len - count - 1]) {
                count += 1;
            }
            self.select = Some((i, count));
        }
        self.draw(core);
    }

    fn sel_inc(&mut self, core: &mut Core) {
        if let Some((i, count)) = self.select {
            let s = &self.state.stack[i];
            let len = s.len();
            if count < len && s[len - count].inc == Some(s[len - count - 1]) {
                self.select = Some((i, count + 1));
                self.draw(core);
            }
        }
    }

    fn sel_dec(&mut self, core: &mut Core) {
        if let Some(sel) = &mut self.select {
            let i = sel.0;
            let count = sel.1;
            if count <= 1 {
                self.select = None;
            } else {
                self.select = Some((i, count - 1));
            }
            self.draw(core);
        }
    }

    /// Mark this state by saving it in history, available to undo
    /// later
    fn mark(&mut self) {
        let v = self.state.pack();
        if let Some(last) = self.history.last()
            && *last == v
        {
            return;
        }
        self.history.push(v);
    }

    /// Restore most recent marked state and remove it from history
    fn undo(&mut self, core: &mut Core) {
        if let Some(data) = self.history.pop() {
            self.state = State::unpack(&data);
            self.select = None;
            self.draw(core);
        }
    }

    /// Move selected cards to the given stack or to top if the stack
    /// is the selected stack
    fn move_to(&mut self, core: &mut Core, to: usize) {
        let Some((fr, cnt)) = self.select else {
            return;
        };
        self.select = None;
        self.mark();

        let s = &mut self.state;
        let Some(fr_last) = s.stack[fr].peek_last() else {
            return;
        };

        if fr == to {
            // Move to top
            for pi in (1..9).rev() {
                let do_move = if let Some(to_last) = s.pile[pi].peek_last() {
                    to_last.inc == Some(fr_last)
                } else {
                    fr_last.num == 1
                };
                if do_move {
                    for _ in 0..cnt {
                        if let Some(card) = s.stack[fr].pick_last() {
                            s.pile[pi].add(card);
                        }
                    }
                    break;
                }
            }
            if self.is_finished()
                && let Some(ret) = self.ret.take()
            {
                ret!([ret], self.score(core));
            }
        } else {
            // Move to another pile
            let mut copy_cnt = cnt;
            if let Some(to_last) = s.stack[to].peek_last() {
                copy_cnt = copy_cnt.min(to_last.num.saturating_sub(fr_last.num) as usize);
                if to_last.num != fr_last.num + copy_cnt as u8 {
                    copy_cnt = 0;
                }
            }

            let mut tmp = Vec::new();
            for _ in 0..copy_cnt {
                tmp.push(s.stack[fr].pick_last().unwrap());
            }
            while let Some(card) = tmp.pop() {
                s.stack[to].add(card);
            }
        }
        self.draw(core);
    }

    /// Move card down from stock pile
    fn move_down(&mut self, core: &mut Core) {
        self.mark();
        if let Some(card) = self.state.pile[0].pick_last() {
            self.state.stack[0].add(card);
            self.select = None;
            self.draw(core);
        }
    }

    fn is_finished(&mut self) -> bool {
        for i in 1..9 {
            if self.state.pile[i].len() != 13 {
                return false;
            }
        }
        true
    }

    /// Set the tile to use for drawing, and redraw
    fn layout(&mut self, core: &mut Core, tile: Tile) {
        self.tile = tile;
        self.draw(core);
    }

    /// Draw the playing area
    fn draw(&mut self, core: &mut Core) {
        if let Some(mut r) = self.tile.full(core) {
            r.clear_all_99();

            for col in 0..9 {
                let x = 1 + col as i32 * 8;

                // Pile
                if let Some(card) = self.state.pile[col].peek_last() {
                    if col == 0 {
                        // Facedown pile
                        draw::card_back(&mut r, 0, x);
                    } else {
                        draw::card(&mut r, 0, x, card);
                    }
                } else {
                    draw::card_space(&mut r, 0, x);
                }

                // Index number
                r.hfb(7)
                    .at(CARD_SY, x)
                    .hfb(70)
                    .char((49 + col as u8) as char);

                // Stack
                let y0 = CARD_SY + 1;
                let y1 = r.sy();
                let hand = &self.state.stack[col];
                draw::card_space(&mut r, y0, x);

                let selected = self
                    .select
                    .map(|(index, count)| if col == index { count } else { 0 })
                    .unwrap_or(0);
                let len = hand.len();
                let sel_i = len.saturating_sub(selected);
                let space = y1 - y0 - 1;
                let mut y = y0;
                let mut i = 0;
                if len as i32 + CARD_SY > space {
                    draw::card_dots(&mut r, y, x);
                    y += 1;
                    i = len - (space - CARD_SY) as usize;
                }
                while i < hand.len() {
                    let card = hand[i];
                    if i >= sel_i {
                        draw::card(&mut r, y + 1, x + 1, card);
                    } else {
                        draw::card(&mut r, y, x, card);
                    }
                    i += 1;
                    y += 1;
                }
            }
        }
    }

pub fn sx(&self) -> i32

Get the region size-X, i.e. columns

Examples found in repository

examples/teeclub/main.rs (line 228)

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

examples/fontedit/app.rs (line 170)

    fn draw_cells(&mut self, cx: CX![]) {
        if let Some(mut full) = self.cells_tile.full(cx) {
            let sx = full.sx();
            full.clear_all_99();

            let font_sx = self.font.sx;
            let font_sy = self.font.sy;
            let cell_wid = font_sx * 2;
            let r = full.region(
                0,
                (sx - cell_wid as i32) / 2,
                font_sy as i32,
                cell_wid as i32,
            );
            draw_cell(
                &self.font,
                r,
                self.index,
                171,
                7,
                Some((self.cy, self.cx, self.mode)),
            );
            let max = self.font.index_limit();
            for i in 1..=self.index {
                let r = full.region(
                    0,
                    (sx - (cell_wid * (1 + i * 2)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index - i, 70, 6, None);
            }
            for i in 1..(max - self.index) {
                let r = full.region(
                    0,
                    (sx + (cell_wid * (i * 2 - 1)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index + i, 70, 6, None);
            }
        }
    }

    fn draw_mini(&mut self, cx: CX![]) {
        if let Some(mut full) = self.mini_tile.full(cx) {
            full.clear_all_99();
            let sx = full.sx() * 2;
            let sy = full.sy() * 4;
            let font_sx = self.font.sx as i32;
            let font_sy = self.font.sy as i32;
            let oy = sy.saturating_sub(font_sy) / 2;
            let mut ox = (sx - font_sx) / 2;
            let mut index = self.index;
            while ox > 0 && index > 0 {
                ox -= font_sx;
                index -= 1;
            }
            while ox < sx {
                draw_mini_cell(&self.font, full.full(), oy, ox, index, 170);
                ox += font_sx;
                index += 1;
            }
        }
    }

pub fn get_y(&self) -> i32

Get the current write row (Y-position)

pub fn get_x(&self) -> i32

Get the current write column (X-position)

Examples found in repository

examples/test2.rs (line 116)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

pub fn is_visible(&self) -> bool

Check whether any part of this region is visible on the page

Examples found in repository

examples/fontedit/app.rs (line 198)

    fn draw_cells(&mut self, cx: CX![]) {
        if let Some(mut full) = self.cells_tile.full(cx) {
            let sx = full.sx();
            full.clear_all_99();

            let font_sx = self.font.sx;
            let font_sy = self.font.sy;
            let cell_wid = font_sx * 2;
            let r = full.region(
                0,
                (sx - cell_wid as i32) / 2,
                font_sy as i32,
                cell_wid as i32,
            );
            draw_cell(
                &self.font,
                r,
                self.index,
                171,
                7,
                Some((self.cy, self.cx, self.mode)),
            );
            let max = self.font.index_limit();
            for i in 1..=self.index {
                let r = full.region(
                    0,
                    (sx - (cell_wid * (1 + i * 2)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index - i, 70, 6, None);
            }
            for i in 1..(max - self.index) {
                let r = full.region(
                    0,
                    (sx + (cell_wid * (i * 2 - 1)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index + i, 70, 6, None);
            }
        }
    }

pub fn hfb(&mut self, hfb: u16) -> &mut Self

Change the current HFB

Examples found in repository

examples/teeclub/draw.rs (line 11)

pub fn card(r: &mut Region, y: i32, x: i32, card: Card) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(card.hfb).clear_all();
    r.at(0, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
    r.at(CARD_SY - 1, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
}

/// Draw the back of a card
pub fn card_back(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(27);
    for y in 0..CARD_SY {
        r.at(y, 0).text("||||||");
    }
}

/// Draw the space where a card could go
pub fn card_space(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(71).clear_all();
}

/// Draw "more cards" indicator
pub fn card_dots(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(70);
    for y in 0..CARD_SY {
        r.at(y, 0).text("::::::");
    }
}

examples/teeclub/main.rs (line 176)

    fn draw_scores(&mut self, cx: CX![]) {
        let mut score = self.score;
        let mut last_score = self.last_score;
        if let Some(mut r) = self.scores_tile.full(cx) {
            r.hfb(176).clear_all();
            r.hfb(7).text("SCORES");
            let mut y = 1;
            let last_y = r.sy() - 1;
            let mut draw = move |hfb, sc| {
                if y > 0 {
                    r.at(y, 0).hfb(hfb);
                    write!(r, "{:3}:{:02}", sc / 60, sc % 60).unwrap();
                    y += 1;
                }
            };

            for &s0 in &self.scores {
                if let Some(curr) = score
                    && (curr < s0 || y == last_y)
                {
                    draw(7, curr);
                    score = None;
                }
                if Some(s0) == last_score {
                    draw(173, s0);
                    last_score = None;
                } else {
                    draw(176, s0);
                }
            }
            if let Some(s1) = score {
                draw(173, s1);
            }
        }
    }

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

    fn draw_instructions(mut r: Region<'_>) {
        const TEXT: &str = r"

        Keys: [N] New game; [Q] Quit; [1] to [9] Select cards in
        corresponding column; [+]/[=] or [-] Increase or decrease
        number of selected cards; [1] to [9] If the same digit as the
        selecting keypress, move selected cards to top, if another
        digit, move as many of selected cards as possible to that
        column; [Space] Bring a new card down from the stock pile;
        [BackSp] Go back one move; [<]/[>] Adjust display left/right.

        Rules: The aim is to move all the cards to the top area, the
        spaces the the right of the stock pile.  Each top pile must
        consist of one suit only, stacked in order from Ace up to
        King.  The cards in the main area can be moved around:
        sequences of one or more cards of the same suit may be moved
        on top of a card with the next-higher number, of any suit.
        The bulk of the cards are in the stock pile in the top-left.
        Cards may be brought down from there using Space.

        ";
        let lines: Vec<_> = TEXT.trim().split('\n').map(|s| s.to_string()).collect();
        let n_lines = lines.len();
        let oy = (r.sy() - n_lines as i32) / 2;
        for (i, line) in lines.iter().enumerate() {
            r.at(i as i32 + oy, 7);
            let line = line.trim().replace("[", "\0171 ").replace("]", " \0099");
            r.text(&line);
        }
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Pr('q' | 'Q') => {
                if self.game.is_some() {
                    self.game = None;
                    self.score = None;
                    self.layout(cx);
                } else {
                    stop!(cx);
                }
            }
            Key::Pr('n' | 'N') => {
                self.game = Some(Game::new(
                    cx.now(),
                    ret_some_to!([cx], game_finished() as (Duration)),
                ));
                self.last_score = None;
                self.update_score(cx);
                self.layout(cx);
            }
            Key::Pr('<') => {
                self.adjust -= 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            Key::Pr('>') => {
                self.adjust += 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            _ => {
                if let Some(game) = &mut self.game {
                    game.input(cx, key);
                }
            }
        }
    }

    fn update_score(&mut self, cx: CX![]) {
        if let Some(game) = &mut self.game {
            let dur = game.score(cx);
            let score = dur.as_secs() as i32;
            let to_wait = if Some(score) != self.score {
                self.score = Some(score);
                self.draw_scores(cx);

                // Update 100ms after next change
                1_000_000_000 - dur.subsec_nanos() + 100_000_000
            } else {
                1_000_000_000
            };
            after!(Duration::from_nanos(to_wait as u64), [cx], update_score());
        }
    }

    fn game_finished(&mut self, cx: CX![], dur: Duration) {
        let score = dur.as_secs() as i32;
        self.scores.push(score);
        self.scores.sort_unstable();
        self.save_scores().expect("Failed to save scores");
        self.last_score = Some(score);
        self.score = None;
        self.game = None;
        self.layout(cx);
    }

    fn score_path() -> PathBuf {
        let mut path = std::env::home_dir().unwrap_or_default();
        path.push(".teeclub-scores");
        path
    }

    fn load_scores(&mut self) -> Option<()> {
        let data = std::fs::read_to_string(Self::score_path()).ok()?;
        let mut it = data.split(char::is_whitespace);
        while let Some(tok) = it.next() {
            match tok {
                "adjust:" => {
                    self.adjust = it.next()?.parse::<i32>().ok()?;
                }
                "scores[" => {
                    self.scores = Vec::new();
                    loop {
                        match it.next()? {
                            "]" => break,
                            v => self.scores.push(v.parse::<i32>().ok()?),
                        }
                    }
                    self.scores.sort_unstable();
                }
                "" => (),
                _ => return None,
            }
        }
        Some(())
    }

    fn save_scores(&mut self) -> std::io::Result<()> {
        let mut out = Vec::new();
        let _ = writeln!(out, "adjust: {}", self.adjust);
        let _ = writeln!(out, "scores[");
        for sc in self.scores.iter().take(200) {
            let _ = writeln!(out, "{sc}");
        }
        let _ = writeln!(out, "]");
        std::fs::write(Self::score_path(), out)
    }
}

/// Game state
#[derive(Eq, PartialEq)]
struct State {
    pile: [Hand; 9],
    stack: [Hand; 9],
}

impl State {
    fn pack(&self) -> Vec<u8> {
        let mut out = Vec::new();
        for p in &self.pile {
            p.pack(&mut out);
        }
        for s in &self.stack {
            s.pack(&mut out);
        }
        out
    }

    fn unpack(mut data: &[u8]) -> Self {
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();
        for p in &mut pile {
            *p = Hand::unpack(&mut data);
        }
        for s in &mut stack {
            *s = Hand::unpack(&mut data);
        }
        Self { pile, stack }
    }
}

/// Game state and gameplay handling
struct Game {
    tile: Tile,
    history: Vec<Vec<u8>>,
    state: State,
    select: Option<(usize, usize)>, // (index, count)
    dur: Duration,
    activity: Instant,
    ret: Option<Ret<Duration>>, // Report score for game completion
}

impl Game {
    fn new(start: Instant, ret: Ret<Duration>) -> Self {
        let seed = std::time::SystemTime::UNIX_EPOCH
            .elapsed()
            .map(|d| d.as_nanos() as u64)
            .unwrap_or(0);

        let mut rand = Rand32::new(seed);
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();

        let p0 = &mut pile[0];
        p0.add_deck();
        p0.add_deck();
        p0.shuffle(&mut rand);
        p0.shuffle(&mut rand);

        for _ in 0..5 {
            for s in &mut stack {
                if let Some(card) = p0.pick_last() {
                    s.add(card);
                }
            }
        }

        Self {
            tile: Tile::default(),
            history: Vec::new(),
            state: State { pile, stack },
            select: None,
            dur: Duration::from_secs(0),
            activity: start,
            ret: Some(ret),
        }
    }

    fn select(&mut self, core: &mut Core, i: usize) {
        let s = &self.state.stack[i];
        let len = s.len();
        if len == 0 {
            self.select = None;
        } else {
            let mut count = 1;
            while count < len && s[len - count].inc == Some(s[len - count - 1]) {
                count += 1;
            }
            self.select = Some((i, count));
        }
        self.draw(core);
    }

    fn sel_inc(&mut self, core: &mut Core) {
        if let Some((i, count)) = self.select {
            let s = &self.state.stack[i];
            let len = s.len();
            if count < len && s[len - count].inc == Some(s[len - count - 1]) {
                self.select = Some((i, count + 1));
                self.draw(core);
            }
        }
    }

    fn sel_dec(&mut self, core: &mut Core) {
        if let Some(sel) = &mut self.select {
            let i = sel.0;
            let count = sel.1;
            if count <= 1 {
                self.select = None;
            } else {
                self.select = Some((i, count - 1));
            }
            self.draw(core);
        }
    }

    /// Mark this state by saving it in history, available to undo
    /// later
    fn mark(&mut self) {
        let v = self.state.pack();
        if let Some(last) = self.history.last()
            && *last == v
        {
            return;
        }
        self.history.push(v);
    }

    /// Restore most recent marked state and remove it from history
    fn undo(&mut self, core: &mut Core) {
        if let Some(data) = self.history.pop() {
            self.state = State::unpack(&data);
            self.select = None;
            self.draw(core);
        }
    }

    /// Move selected cards to the given stack or to top if the stack
    /// is the selected stack
    fn move_to(&mut self, core: &mut Core, to: usize) {
        let Some((fr, cnt)) = self.select else {
            return;
        };
        self.select = None;
        self.mark();

        let s = &mut self.state;
        let Some(fr_last) = s.stack[fr].peek_last() else {
            return;
        };

        if fr == to {
            // Move to top
            for pi in (1..9).rev() {
                let do_move = if let Some(to_last) = s.pile[pi].peek_last() {
                    to_last.inc == Some(fr_last)
                } else {
                    fr_last.num == 1
                };
                if do_move {
                    for _ in 0..cnt {
                        if let Some(card) = s.stack[fr].pick_last() {
                            s.pile[pi].add(card);
                        }
                    }
                    break;
                }
            }
            if self.is_finished()
                && let Some(ret) = self.ret.take()
            {
                ret!([ret], self.score(core));
            }
        } else {
            // Move to another pile
            let mut copy_cnt = cnt;
            if let Some(to_last) = s.stack[to].peek_last() {
                copy_cnt = copy_cnt.min(to_last.num.saturating_sub(fr_last.num) as usize);
                if to_last.num != fr_last.num + copy_cnt as u8 {
                    copy_cnt = 0;
                }
            }

            let mut tmp = Vec::new();
            for _ in 0..copy_cnt {
                tmp.push(s.stack[fr].pick_last().unwrap());
            }
            while let Some(card) = tmp.pop() {
                s.stack[to].add(card);
            }
        }
        self.draw(core);
    }

    /// Move card down from stock pile
    fn move_down(&mut self, core: &mut Core) {
        self.mark();
        if let Some(card) = self.state.pile[0].pick_last() {
            self.state.stack[0].add(card);
            self.select = None;
            self.draw(core);
        }
    }

    fn is_finished(&mut self) -> bool {
        for i in 1..9 {
            if self.state.pile[i].len() != 13 {
                return false;
            }
        }
        true
    }

    /// Set the tile to use for drawing, and redraw
    fn layout(&mut self, core: &mut Core, tile: Tile) {
        self.tile = tile;
        self.draw(core);
    }

    /// Draw the playing area
    fn draw(&mut self, core: &mut Core) {
        if let Some(mut r) = self.tile.full(core) {
            r.clear_all_99();

            for col in 0..9 {
                let x = 1 + col as i32 * 8;

                // Pile
                if let Some(card) = self.state.pile[col].peek_last() {
                    if col == 0 {
                        // Facedown pile
                        draw::card_back(&mut r, 0, x);
                    } else {
                        draw::card(&mut r, 0, x, card);
                    }
                } else {
                    draw::card_space(&mut r, 0, x);
                }

                // Index number
                r.hfb(7)
                    .at(CARD_SY, x)
                    .hfb(70)
                    .char((49 + col as u8) as char);

                // Stack
                let y0 = CARD_SY + 1;
                let y1 = r.sy();
                let hand = &self.state.stack[col];
                draw::card_space(&mut r, y0, x);

                let selected = self
                    .select
                    .map(|(index, count)| if col == index { count } else { 0 })
                    .unwrap_or(0);
                let len = hand.len();
                let sel_i = len.saturating_sub(selected);
                let space = y1 - y0 - 1;
                let mut y = y0;
                let mut i = 0;
                if len as i32 + CARD_SY > space {
                    draw::card_dots(&mut r, y, x);
                    y += 1;
                    i = len - (space - CARD_SY) as usize;
                }
                while i < hand.len() {
                    let card = hand[i];
                    if i >= sel_i {
                        draw::card(&mut r, y + 1, x + 1, card);
                    } else {
                        draw::card(&mut r, y, x, card);
                    }
                    i += 1;
                    y += 1;
                }
            }
        }
    }

examples/test2.rs (line 105)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

examples/fontedit/app.rs (line 109)

    fn redraw(&mut self, cx: CX![]) {
        if let Some(ref tsh) = self.tsh {
            let out = tsh.output(cx);
            out.attr_99().cursor_show().scroll_up().save_cleanup();
            out.cursor_hide().clear_all_99_and_remote();

            // Draw fixed stuff here, then break out and store
            // sub-tiles for areas that need to be updated later
            let tile = tsh.tile(cx);
            let sx = tile.sx();
            let sy = tile.sy();
            let split_y1 = sy - self.font.sy as i32;
            let split_y0 = split_y1.min(10);
            let (top, _, cells_tile) = tile.split_yy(split_y0, split_y1);
            let spare = sx.saturating_sub(80);
            let (ox, mini_sx) = if (spare as usize) < self.font.sx / 2 {
                (spare / 2, 0)
            } else {
                (0, spare)
            };
            let (_, rest) = top.split_x(ox);
            let (param_tile, mini_tile, mut keys_tile) = rest.split_xx(40, 40 + mini_sx);

            if let Some(mut r) = keys_tile.region(cx, 0, 0, split_y0, 40) {
                r.hfb(172).clear_all();
                let text = "\
Keys: Arrows move, [Space] change pixel
Mode on/off: [d] draw, [r] roll
Fill: [f] flood, [v] vert, [h] horiz
[n] new glyph, [u] undo, [l] ruler line
Clip: [c] copy, [P] paste.
Index: [PgUp] [PgDn] [Home] [End].
[S] save, [Q] save+quit, [^C] hard quit
Edit the font file directly to change
font size or codepoint numbers.";
                r.text(&text.replace('[', "\0171 ").replace(']', " \0172"));
            }
            self.cells_tile = cells_tile;
            self.param_tile = param_tile;
            self.mini_tile = mini_tile;

            self.draw_cells(cx);
            self.draw_mini(cx);
            self.draw_param(cx);
        }
    }

    fn draw_param(&mut self, cx: CX![]) {
        if let Some(mut r) = self.param_tile.full(cx) {
            r.hfb(172).clear_all();

            // Use sub-region to clip the filename if it's too long
            r.region(0, 0, 1, 39)
                .hfb(172)
                .text("File:  ")
                .text(&self.font.path.to_string_lossy());

            let count = self.font.index_limit();
            let index = self.index;

            let state = if let Some(ref err) = self.save_error {
                err
            } else if self.unsaved {
                "UNSAVED"
            } else {
                ""
            };
            let cp = self.font.chars[index].cp;
            let ch = match cp {
                32..=126 | 160.. => char::from_u32(cp).unwrap_or('?'),
                _ => '?',
            };
            let sx = self.font.sx;
            let sy = self.font.sy;

            r.at(1, 0);
            let _ = writeln!(r, "Size:  {sx} x {sy}, {count} glyphs");
            let _ = writeln!(r, "Index: {index} U+{cp:04x} '{ch}'");
            let _ = writeln!(r, "Mode:  {}", self.mode.caps());
            let _ = writeln!(r, "State: {}", state);
        }
    }

    fn draw_cells(&mut self, cx: CX![]) {
        if let Some(mut full) = self.cells_tile.full(cx) {
            let sx = full.sx();
            full.clear_all_99();

            let font_sx = self.font.sx;
            let font_sy = self.font.sy;
            let cell_wid = font_sx * 2;
            let r = full.region(
                0,
                (sx - cell_wid as i32) / 2,
                font_sy as i32,
                cell_wid as i32,
            );
            draw_cell(
                &self.font,
                r,
                self.index,
                171,
                7,
                Some((self.cy, self.cx, self.mode)),
            );
            let max = self.font.index_limit();
            for i in 1..=self.index {
                let r = full.region(
                    0,
                    (sx - (cell_wid * (1 + i * 2)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index - i, 70, 6, None);
            }
            for i in 1..(max - self.index) {
                let r = full.region(
                    0,
                    (sx + (cell_wid * (i * 2 - 1)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index + i, 70, 6, None);
            }
        }
    }

    fn draw_mini(&mut self, cx: CX![]) {
        if let Some(mut full) = self.mini_tile.full(cx) {
            full.clear_all_99();
            let sx = full.sx() * 2;
            let sy = full.sy() * 4;
            let font_sx = self.font.sx as i32;
            let font_sy = self.font.sy as i32;
            let oy = sy.saturating_sub(font_sy) / 2;
            let mut ox = (sx - font_sx) / 2;
            let mut index = self.index;
            while ox > 0 && index > 0 {
                ox -= font_sx;
                index -= 1;
            }
            while ox < sx {
                draw_mini_cell(&self.font, full.full(), oy, ox, index, 170);
                ox += font_sx;
                index += 1;
            }
        }
    }

    fn draw_all(&mut self, cx: CX![]) {
        self.draw_cells(cx);
        self.draw_mini(cx);
        self.draw_param(cx);
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Left => {
                if self.cx > 0 {
                    self.move_or_draw(cx, 0, -1)
                }
            }
            Key::Right => {
                if self.cx + 1 < self.font.sx {
                    self.move_or_draw(cx, 0, 1)
                }
            }
            Key::Up => {
                if self.cy > 0 {
                    self.move_or_draw(cx, -1, 0)
                }
            }
            Key::Down => {
                if self.cy + 1 < self.font.sy {
                    self.move_or_draw(cx, 1, 0)
                }
            }
            Key::PgUp => {
                if self.index > 0 {
                    self.index -= 1;
                    self.draw_all(cx);
                }
            }
            Key::PgDn => {
                if self.index + 1 < self.font.index_limit() {
                    self.index += 1;
                    self.draw_all(cx);
                }
            }
            Key::Home => {
                self.index = 0;
                self.draw_all(cx);
            }
            Key::End => {
                self.index = self.font.index_limit() - 1;
                self.draw_all(cx);
            }
            Key::Pr(' ') => {
                self.undo_push();
                self.unsaved = true;
                let curr = self.font.get(self.index, self.cy, self.cx);
                self.font.set(self.index, self.cy, self.cx, !curr);
                self.draw_all(cx);
            }
            Key::Pr('d') => {
                self.mode = match self.mode {
                    Mode::Draw => Mode::Move,
                    _ => Mode::Draw,
                };
                self.draw_all(cx);
            }
            Key::Pr('r') => {
                self.mode = match self.mode {
                    Mode::Roll => Mode::Move,
                    _ => Mode::Roll,
                };
                self.draw_all(cx);
            }
            Key::Pr('f') => {
                self.undo_push();
                self.unsaved = true;
                self.font.fill(self.index, self.cy, self.cx, true, true);
                self.draw_all(cx);
            }
            Key::Pr('h') => {
                self.undo_push();
                self.unsaved = true;
                self.font.fill(self.index, self.cy, self.cx, false, true);
                self.draw_all(cx);
            }
            Key::Pr('v') => {
                self.undo_push();
                self.unsaved = true;
                self.font.fill(self.index, self.cy, self.cx, true, false);
                self.draw_all(cx);
            }
            Key::Pr('u') => {
                if let Some(font) = self.undo.pop_front() {
                    self.font = font;
                    let limit = self.font.index_limit();
                    self.index = self.index.min(limit - 1);
                    self.draw_all(cx);
                }
            }
            Key::Pr('l') => {
                self.font.rule_bm ^= 1 << self.cy;
                self.unsaved = true;
                self.draw_all(cx);
            }
            Key::Pr('n') => {
                self.undo_push();
                self.unsaved = true;
                self.index = self.font.index_limit();
                self.font.add_glyph();
                self.draw_param(cx);
                self.draw_cells(cx);
            }
            Key::Pr('c') => {
                self.clip = self.font.get_glyph(self.index);
            }
            Key::Pr('P') => {
                if !self.clip.is_empty() {
                    self.undo_push();
                    self.unsaved = true;
                    self.font.set_glyph(self.index, &self.clip);
                    self.draw_all(cx);
                }
            }
            Key::Pr('S') => {
                if let Err(e) = self.font.save() {
                    self.save_error = Some(e.to_string());
                } else {
                    self.save_error = None;
                    self.unsaved = false;
                }
                self.draw_param(cx);
            }
            Key::Pr('Q') => {
                if let Err(e) = self.font.save() {
                    fail!(cx, e);
                } else {
                    stop!(cx);
                }
            }
            _ => call!([self.term], bell()),
        }
    }

    fn move_or_draw(&mut self, cx: CX![], dy: i32, dx: i32) {
        match self.mode {
            Mode::Move => {
                self.cx = (self.cx as i32 + dx) as usize;
                self.cy = (self.cy as i32 + dy) as usize;
                self.draw_cells(cx);
            }
            Mode::Draw => {
                self.undo_push();
                self.unsaved = true;
                let curr = self.font.get(self.index, self.cy, self.cx);
                self.cx = (self.cx as i32 + dx) as usize;
                self.cy = (self.cy as i32 + dy) as usize;
                self.font.set(self.index, self.cy, self.cx, curr);
                self.draw_all(cx);
            }
            Mode::Roll => {
                self.undo_push();
                if dx != 0 {
                    self.font.roll_horiz(self.index, dx);
                }
                if dy != 0 {
                    self.font.roll_vert(self.index, dy);
                }
                self.draw_all(cx);
            }
        }
    }

    fn undo_push(&mut self) {
        self.undo.push_front(self.font.clone());
        while self.undo.len() > 50 {
            self.undo.pop_back();
        }
    }
}

fn draw_cell(
    font: &Font,
    mut r: Region,
    index: usize,
    black: u16,
    white: u16,
    curs: Option<(usize, usize, Mode)>,
) {
    let form = &font.chars[index].form;
    for y in 0..font.sy {
        let rule = ((font.rule_bm >> y) & 1) != 0;
        for x in 0..font.sx {
            r.hfb(if form[x + y * font.sx] { white } else { black });
            let mut text = if rule { "--" } else { "  " };
            if let Some((cy, cx, mode)) = curs
                && cy == y
                && cx == x
            {
                text = mode.cursor();
            }
            r.text(text);
        }
    }
}

pub fn at(&mut self, wy: i32, wx: i32) -> &mut Self

Change the write position to the given position relative to region top-left.

Examples found in repository

examples/teeclub/draw.rs (line 12)

pub fn card(r: &mut Region, y: i32, x: i32, card: Card) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(card.hfb).clear_all();
    r.at(0, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
    r.at(CARD_SY - 1, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
}

/// Draw the back of a card
pub fn card_back(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(27);
    for y in 0..CARD_SY {
        r.at(y, 0).text("||||||");
    }
}

/// Draw the space where a card could go
pub fn card_space(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(71).clear_all();
}

/// Draw "more cards" indicator
pub fn card_dots(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(70);
    for y in 0..CARD_SY {
        r.at(y, 0).text("::::::");
    }
}

examples/teeclub/main.rs (line 182)

    fn draw_scores(&mut self, cx: CX![]) {
        let mut score = self.score;
        let mut last_score = self.last_score;
        if let Some(mut r) = self.scores_tile.full(cx) {
            r.hfb(176).clear_all();
            r.hfb(7).text("SCORES");
            let mut y = 1;
            let last_y = r.sy() - 1;
            let mut draw = move |hfb, sc| {
                if y > 0 {
                    r.at(y, 0).hfb(hfb);
                    write!(r, "{:3}:{:02}", sc / 60, sc % 60).unwrap();
                    y += 1;
                }
            };

            for &s0 in &self.scores {
                if let Some(curr) = score
                    && (curr < s0 || y == last_y)
                {
                    draw(7, curr);
                    score = None;
                }
                if Some(s0) == last_score {
                    draw(173, s0);
                    last_score = None;
                } else {
                    draw(176, s0);
                }
            }
            if let Some(s1) = score {
                draw(173, s1);
            }
        }
    }

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

    fn draw_instructions(mut r: Region<'_>) {
        const TEXT: &str = r"

        Keys: [N] New game; [Q] Quit; [1] to [9] Select cards in
        corresponding column; [+]/[=] or [-] Increase or decrease
        number of selected cards; [1] to [9] If the same digit as the
        selecting keypress, move selected cards to top, if another
        digit, move as many of selected cards as possible to that
        column; [Space] Bring a new card down from the stock pile;
        [BackSp] Go back one move; [<]/[>] Adjust display left/right.

        Rules: The aim is to move all the cards to the top area, the
        spaces the the right of the stock pile.  Each top pile must
        consist of one suit only, stacked in order from Ace up to
        King.  The cards in the main area can be moved around:
        sequences of one or more cards of the same suit may be moved
        on top of a card with the next-higher number, of any suit.
        The bulk of the cards are in the stock pile in the top-left.
        Cards may be brought down from there using Space.

        ";
        let lines: Vec<_> = TEXT.trim().split('\n').map(|s| s.to_string()).collect();
        let n_lines = lines.len();
        let oy = (r.sy() - n_lines as i32) / 2;
        for (i, line) in lines.iter().enumerate() {
            r.at(i as i32 + oy, 7);
            let line = line.trim().replace("[", "\0171 ").replace("]", " \0099");
            r.text(&line);
        }
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Pr('q' | 'Q') => {
                if self.game.is_some() {
                    self.game = None;
                    self.score = None;
                    self.layout(cx);
                } else {
                    stop!(cx);
                }
            }
            Key::Pr('n' | 'N') => {
                self.game = Some(Game::new(
                    cx.now(),
                    ret_some_to!([cx], game_finished() as (Duration)),
                ));
                self.last_score = None;
                self.update_score(cx);
                self.layout(cx);
            }
            Key::Pr('<') => {
                self.adjust -= 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            Key::Pr('>') => {
                self.adjust += 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            _ => {
                if let Some(game) = &mut self.game {
                    game.input(cx, key);
                }
            }
        }
    }

    fn update_score(&mut self, cx: CX![]) {
        if let Some(game) = &mut self.game {
            let dur = game.score(cx);
            let score = dur.as_secs() as i32;
            let to_wait = if Some(score) != self.score {
                self.score = Some(score);
                self.draw_scores(cx);

                // Update 100ms after next change
                1_000_000_000 - dur.subsec_nanos() + 100_000_000
            } else {
                1_000_000_000
            };
            after!(Duration::from_nanos(to_wait as u64), [cx], update_score());
        }
    }

    fn game_finished(&mut self, cx: CX![], dur: Duration) {
        let score = dur.as_secs() as i32;
        self.scores.push(score);
        self.scores.sort_unstable();
        self.save_scores().expect("Failed to save scores");
        self.last_score = Some(score);
        self.score = None;
        self.game = None;
        self.layout(cx);
    }

    fn score_path() -> PathBuf {
        let mut path = std::env::home_dir().unwrap_or_default();
        path.push(".teeclub-scores");
        path
    }

    fn load_scores(&mut self) -> Option<()> {
        let data = std::fs::read_to_string(Self::score_path()).ok()?;
        let mut it = data.split(char::is_whitespace);
        while let Some(tok) = it.next() {
            match tok {
                "adjust:" => {
                    self.adjust = it.next()?.parse::<i32>().ok()?;
                }
                "scores[" => {
                    self.scores = Vec::new();
                    loop {
                        match it.next()? {
                            "]" => break,
                            v => self.scores.push(v.parse::<i32>().ok()?),
                        }
                    }
                    self.scores.sort_unstable();
                }
                "" => (),
                _ => return None,
            }
        }
        Some(())
    }

    fn save_scores(&mut self) -> std::io::Result<()> {
        let mut out = Vec::new();
        let _ = writeln!(out, "adjust: {}", self.adjust);
        let _ = writeln!(out, "scores[");
        for sc in self.scores.iter().take(200) {
            let _ = writeln!(out, "{sc}");
        }
        let _ = writeln!(out, "]");
        std::fs::write(Self::score_path(), out)
    }
}

/// Game state
#[derive(Eq, PartialEq)]
struct State {
    pile: [Hand; 9],
    stack: [Hand; 9],
}

impl State {
    fn pack(&self) -> Vec<u8> {
        let mut out = Vec::new();
        for p in &self.pile {
            p.pack(&mut out);
        }
        for s in &self.stack {
            s.pack(&mut out);
        }
        out
    }

    fn unpack(mut data: &[u8]) -> Self {
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();
        for p in &mut pile {
            *p = Hand::unpack(&mut data);
        }
        for s in &mut stack {
            *s = Hand::unpack(&mut data);
        }
        Self { pile, stack }
    }
}

/// Game state and gameplay handling
struct Game {
    tile: Tile,
    history: Vec<Vec<u8>>,
    state: State,
    select: Option<(usize, usize)>, // (index, count)
    dur: Duration,
    activity: Instant,
    ret: Option<Ret<Duration>>, // Report score for game completion
}

impl Game {
    fn new(start: Instant, ret: Ret<Duration>) -> Self {
        let seed = std::time::SystemTime::UNIX_EPOCH
            .elapsed()
            .map(|d| d.as_nanos() as u64)
            .unwrap_or(0);

        let mut rand = Rand32::new(seed);
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();

        let p0 = &mut pile[0];
        p0.add_deck();
        p0.add_deck();
        p0.shuffle(&mut rand);
        p0.shuffle(&mut rand);

        for _ in 0..5 {
            for s in &mut stack {
                if let Some(card) = p0.pick_last() {
                    s.add(card);
                }
            }
        }

        Self {
            tile: Tile::default(),
            history: Vec::new(),
            state: State { pile, stack },
            select: None,
            dur: Duration::from_secs(0),
            activity: start,
            ret: Some(ret),
        }
    }

    fn select(&mut self, core: &mut Core, i: usize) {
        let s = &self.state.stack[i];
        let len = s.len();
        if len == 0 {
            self.select = None;
        } else {
            let mut count = 1;
            while count < len && s[len - count].inc == Some(s[len - count - 1]) {
                count += 1;
            }
            self.select = Some((i, count));
        }
        self.draw(core);
    }

    fn sel_inc(&mut self, core: &mut Core) {
        if let Some((i, count)) = self.select {
            let s = &self.state.stack[i];
            let len = s.len();
            if count < len && s[len - count].inc == Some(s[len - count - 1]) {
                self.select = Some((i, count + 1));
                self.draw(core);
            }
        }
    }

    fn sel_dec(&mut self, core: &mut Core) {
        if let Some(sel) = &mut self.select {
            let i = sel.0;
            let count = sel.1;
            if count <= 1 {
                self.select = None;
            } else {
                self.select = Some((i, count - 1));
            }
            self.draw(core);
        }
    }

    /// Mark this state by saving it in history, available to undo
    /// later
    fn mark(&mut self) {
        let v = self.state.pack();
        if let Some(last) = self.history.last()
            && *last == v
        {
            return;
        }
        self.history.push(v);
    }

    /// Restore most recent marked state and remove it from history
    fn undo(&mut self, core: &mut Core) {
        if let Some(data) = self.history.pop() {
            self.state = State::unpack(&data);
            self.select = None;
            self.draw(core);
        }
    }

    /// Move selected cards to the given stack or to top if the stack
    /// is the selected stack
    fn move_to(&mut self, core: &mut Core, to: usize) {
        let Some((fr, cnt)) = self.select else {
            return;
        };
        self.select = None;
        self.mark();

        let s = &mut self.state;
        let Some(fr_last) = s.stack[fr].peek_last() else {
            return;
        };

        if fr == to {
            // Move to top
            for pi in (1..9).rev() {
                let do_move = if let Some(to_last) = s.pile[pi].peek_last() {
                    to_last.inc == Some(fr_last)
                } else {
                    fr_last.num == 1
                };
                if do_move {
                    for _ in 0..cnt {
                        if let Some(card) = s.stack[fr].pick_last() {
                            s.pile[pi].add(card);
                        }
                    }
                    break;
                }
            }
            if self.is_finished()
                && let Some(ret) = self.ret.take()
            {
                ret!([ret], self.score(core));
            }
        } else {
            // Move to another pile
            let mut copy_cnt = cnt;
            if let Some(to_last) = s.stack[to].peek_last() {
                copy_cnt = copy_cnt.min(to_last.num.saturating_sub(fr_last.num) as usize);
                if to_last.num != fr_last.num + copy_cnt as u8 {
                    copy_cnt = 0;
                }
            }

            let mut tmp = Vec::new();
            for _ in 0..copy_cnt {
                tmp.push(s.stack[fr].pick_last().unwrap());
            }
            while let Some(card) = tmp.pop() {
                s.stack[to].add(card);
            }
        }
        self.draw(core);
    }

    /// Move card down from stock pile
    fn move_down(&mut self, core: &mut Core) {
        self.mark();
        if let Some(card) = self.state.pile[0].pick_last() {
            self.state.stack[0].add(card);
            self.select = None;
            self.draw(core);
        }
    }

    fn is_finished(&mut self) -> bool {
        for i in 1..9 {
            if self.state.pile[i].len() != 13 {
                return false;
            }
        }
        true
    }

    /// Set the tile to use for drawing, and redraw
    fn layout(&mut self, core: &mut Core, tile: Tile) {
        self.tile = tile;
        self.draw(core);
    }

    /// Draw the playing area
    fn draw(&mut self, core: &mut Core) {
        if let Some(mut r) = self.tile.full(core) {
            r.clear_all_99();

            for col in 0..9 {
                let x = 1 + col as i32 * 8;

                // Pile
                if let Some(card) = self.state.pile[col].peek_last() {
                    if col == 0 {
                        // Facedown pile
                        draw::card_back(&mut r, 0, x);
                    } else {
                        draw::card(&mut r, 0, x, card);
                    }
                } else {
                    draw::card_space(&mut r, 0, x);
                }

                // Index number
                r.hfb(7)
                    .at(CARD_SY, x)
                    .hfb(70)
                    .char((49 + col as u8) as char);

                // Stack
                let y0 = CARD_SY + 1;
                let y1 = r.sy();
                let hand = &self.state.stack[col];
                draw::card_space(&mut r, y0, x);

                let selected = self
                    .select
                    .map(|(index, count)| if col == index { count } else { 0 })
                    .unwrap_or(0);
                let len = hand.len();
                let sel_i = len.saturating_sub(selected);
                let space = y1 - y0 - 1;
                let mut y = y0;
                let mut i = 0;
                if len as i32 + CARD_SY > space {
                    draw::card_dots(&mut r, y, x);
                    y += 1;
                    i = len - (space - CARD_SY) as usize;
                }
                while i < hand.len() {
                    let card = hand[i];
                    if i >= sel_i {
                        draw::card(&mut r, y + 1, x + 1, card);
                    } else {
                        draw::card(&mut r, y, x, card);
                    }
                    i += 1;
                    y += 1;
                }
            }
        }
    }

examples/fontedit/app.rs (line 160)

    fn draw_param(&mut self, cx: CX![]) {
        if let Some(mut r) = self.param_tile.full(cx) {
            r.hfb(172).clear_all();

            // Use sub-region to clip the filename if it's too long
            r.region(0, 0, 1, 39)
                .hfb(172)
                .text("File:  ")
                .text(&self.font.path.to_string_lossy());

            let count = self.font.index_limit();
            let index = self.index;

            let state = if let Some(ref err) = self.save_error {
                err
            } else if self.unsaved {
                "UNSAVED"
            } else {
                ""
            };
            let cp = self.font.chars[index].cp;
            let ch = match cp {
                32..=126 | 160.. => char::from_u32(cp).unwrap_or('?'),
                _ => '?',
            };
            let sx = self.font.sx;
            let sy = self.font.sy;

            r.at(1, 0);
            let _ = writeln!(r, "Size:  {sx} x {sy}, {count} glyphs");
            let _ = writeln!(r, "Index: {index} U+{cp:04x} '{ch}'");
            let _ = writeln!(r, "Mode:  {}", self.mode.caps());
            let _ = writeln!(r, "State: {}", state);
        }
    }

examples/test2.rs (line 105)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

pub fn char(&mut self, ch: char) -> &mut Self

Add a char to the region. This should represent a single glyph. Glyphs using combining characters can’t be added this way.

Examples found in repository

examples/teeclub/main.rs (line 234)

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

    fn draw_instructions(mut r: Region<'_>) {
        const TEXT: &str = r"

        Keys: [N] New game; [Q] Quit; [1] to [9] Select cards in
        corresponding column; [+]/[=] or [-] Increase or decrease
        number of selected cards; [1] to [9] If the same digit as the
        selecting keypress, move selected cards to top, if another
        digit, move as many of selected cards as possible to that
        column; [Space] Bring a new card down from the stock pile;
        [BackSp] Go back one move; [<]/[>] Adjust display left/right.

        Rules: The aim is to move all the cards to the top area, the
        spaces the the right of the stock pile.  Each top pile must
        consist of one suit only, stacked in order from Ace up to
        King.  The cards in the main area can be moved around:
        sequences of one or more cards of the same suit may be moved
        on top of a card with the next-higher number, of any suit.
        The bulk of the cards are in the stock pile in the top-left.
        Cards may be brought down from there using Space.

        ";
        let lines: Vec<_> = TEXT.trim().split('\n').map(|s| s.to_string()).collect();
        let n_lines = lines.len();
        let oy = (r.sy() - n_lines as i32) / 2;
        for (i, line) in lines.iter().enumerate() {
            r.at(i as i32 + oy, 7);
            let line = line.trim().replace("[", "\0171 ").replace("]", " \0099");
            r.text(&line);
        }
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Pr('q' | 'Q') => {
                if self.game.is_some() {
                    self.game = None;
                    self.score = None;
                    self.layout(cx);
                } else {
                    stop!(cx);
                }
            }
            Key::Pr('n' | 'N') => {
                self.game = Some(Game::new(
                    cx.now(),
                    ret_some_to!([cx], game_finished() as (Duration)),
                ));
                self.last_score = None;
                self.update_score(cx);
                self.layout(cx);
            }
            Key::Pr('<') => {
                self.adjust -= 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            Key::Pr('>') => {
                self.adjust += 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            _ => {
                if let Some(game) = &mut self.game {
                    game.input(cx, key);
                }
            }
        }
    }

    fn update_score(&mut self, cx: CX![]) {
        if let Some(game) = &mut self.game {
            let dur = game.score(cx);
            let score = dur.as_secs() as i32;
            let to_wait = if Some(score) != self.score {
                self.score = Some(score);
                self.draw_scores(cx);

                // Update 100ms after next change
                1_000_000_000 - dur.subsec_nanos() + 100_000_000
            } else {
                1_000_000_000
            };
            after!(Duration::from_nanos(to_wait as u64), [cx], update_score());
        }
    }

    fn game_finished(&mut self, cx: CX![], dur: Duration) {
        let score = dur.as_secs() as i32;
        self.scores.push(score);
        self.scores.sort_unstable();
        self.save_scores().expect("Failed to save scores");
        self.last_score = Some(score);
        self.score = None;
        self.game = None;
        self.layout(cx);
    }

    fn score_path() -> PathBuf {
        let mut path = std::env::home_dir().unwrap_or_default();
        path.push(".teeclub-scores");
        path
    }

    fn load_scores(&mut self) -> Option<()> {
        let data = std::fs::read_to_string(Self::score_path()).ok()?;
        let mut it = data.split(char::is_whitespace);
        while let Some(tok) = it.next() {
            match tok {
                "adjust:" => {
                    self.adjust = it.next()?.parse::<i32>().ok()?;
                }
                "scores[" => {
                    self.scores = Vec::new();
                    loop {
                        match it.next()? {
                            "]" => break,
                            v => self.scores.push(v.parse::<i32>().ok()?),
                        }
                    }
                    self.scores.sort_unstable();
                }
                "" => (),
                _ => return None,
            }
        }
        Some(())
    }

    fn save_scores(&mut self) -> std::io::Result<()> {
        let mut out = Vec::new();
        let _ = writeln!(out, "adjust: {}", self.adjust);
        let _ = writeln!(out, "scores[");
        for sc in self.scores.iter().take(200) {
            let _ = writeln!(out, "{sc}");
        }
        let _ = writeln!(out, "]");
        std::fs::write(Self::score_path(), out)
    }
}

/// Game state
#[derive(Eq, PartialEq)]
struct State {
    pile: [Hand; 9],
    stack: [Hand; 9],
}

impl State {
    fn pack(&self) -> Vec<u8> {
        let mut out = Vec::new();
        for p in &self.pile {
            p.pack(&mut out);
        }
        for s in &self.stack {
            s.pack(&mut out);
        }
        out
    }

    fn unpack(mut data: &[u8]) -> Self {
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();
        for p in &mut pile {
            *p = Hand::unpack(&mut data);
        }
        for s in &mut stack {
            *s = Hand::unpack(&mut data);
        }
        Self { pile, stack }
    }
}

/// Game state and gameplay handling
struct Game {
    tile: Tile,
    history: Vec<Vec<u8>>,
    state: State,
    select: Option<(usize, usize)>, // (index, count)
    dur: Duration,
    activity: Instant,
    ret: Option<Ret<Duration>>, // Report score for game completion
}

impl Game {
    fn new(start: Instant, ret: Ret<Duration>) -> Self {
        let seed = std::time::SystemTime::UNIX_EPOCH
            .elapsed()
            .map(|d| d.as_nanos() as u64)
            .unwrap_or(0);

        let mut rand = Rand32::new(seed);
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();

        let p0 = &mut pile[0];
        p0.add_deck();
        p0.add_deck();
        p0.shuffle(&mut rand);
        p0.shuffle(&mut rand);

        for _ in 0..5 {
            for s in &mut stack {
                if let Some(card) = p0.pick_last() {
                    s.add(card);
                }
            }
        }

        Self {
            tile: Tile::default(),
            history: Vec::new(),
            state: State { pile, stack },
            select: None,
            dur: Duration::from_secs(0),
            activity: start,
            ret: Some(ret),
        }
    }

    fn select(&mut self, core: &mut Core, i: usize) {
        let s = &self.state.stack[i];
        let len = s.len();
        if len == 0 {
            self.select = None;
        } else {
            let mut count = 1;
            while count < len && s[len - count].inc == Some(s[len - count - 1]) {
                count += 1;
            }
            self.select = Some((i, count));
        }
        self.draw(core);
    }

    fn sel_inc(&mut self, core: &mut Core) {
        if let Some((i, count)) = self.select {
            let s = &self.state.stack[i];
            let len = s.len();
            if count < len && s[len - count].inc == Some(s[len - count - 1]) {
                self.select = Some((i, count + 1));
                self.draw(core);
            }
        }
    }

    fn sel_dec(&mut self, core: &mut Core) {
        if let Some(sel) = &mut self.select {
            let i = sel.0;
            let count = sel.1;
            if count <= 1 {
                self.select = None;
            } else {
                self.select = Some((i, count - 1));
            }
            self.draw(core);
        }
    }

    /// Mark this state by saving it in history, available to undo
    /// later
    fn mark(&mut self) {
        let v = self.state.pack();
        if let Some(last) = self.history.last()
            && *last == v
        {
            return;
        }
        self.history.push(v);
    }

    /// Restore most recent marked state and remove it from history
    fn undo(&mut self, core: &mut Core) {
        if let Some(data) = self.history.pop() {
            self.state = State::unpack(&data);
            self.select = None;
            self.draw(core);
        }
    }

    /// Move selected cards to the given stack or to top if the stack
    /// is the selected stack
    fn move_to(&mut self, core: &mut Core, to: usize) {
        let Some((fr, cnt)) = self.select else {
            return;
        };
        self.select = None;
        self.mark();

        let s = &mut self.state;
        let Some(fr_last) = s.stack[fr].peek_last() else {
            return;
        };

        if fr == to {
            // Move to top
            for pi in (1..9).rev() {
                let do_move = if let Some(to_last) = s.pile[pi].peek_last() {
                    to_last.inc == Some(fr_last)
                } else {
                    fr_last.num == 1
                };
                if do_move {
                    for _ in 0..cnt {
                        if let Some(card) = s.stack[fr].pick_last() {
                            s.pile[pi].add(card);
                        }
                    }
                    break;
                }
            }
            if self.is_finished()
                && let Some(ret) = self.ret.take()
            {
                ret!([ret], self.score(core));
            }
        } else {
            // Move to another pile
            let mut copy_cnt = cnt;
            if let Some(to_last) = s.stack[to].peek_last() {
                copy_cnt = copy_cnt.min(to_last.num.saturating_sub(fr_last.num) as usize);
                if to_last.num != fr_last.num + copy_cnt as u8 {
                    copy_cnt = 0;
                }
            }

            let mut tmp = Vec::new();
            for _ in 0..copy_cnt {
                tmp.push(s.stack[fr].pick_last().unwrap());
            }
            while let Some(card) = tmp.pop() {
                s.stack[to].add(card);
            }
        }
        self.draw(core);
    }

    /// Move card down from stock pile
    fn move_down(&mut self, core: &mut Core) {
        self.mark();
        if let Some(card) = self.state.pile[0].pick_last() {
            self.state.stack[0].add(card);
            self.select = None;
            self.draw(core);
        }
    }

    fn is_finished(&mut self) -> bool {
        for i in 1..9 {
            if self.state.pile[i].len() != 13 {
                return false;
            }
        }
        true
    }

    /// Set the tile to use for drawing, and redraw
    fn layout(&mut self, core: &mut Core, tile: Tile) {
        self.tile = tile;
        self.draw(core);
    }

    /// Draw the playing area
    fn draw(&mut self, core: &mut Core) {
        if let Some(mut r) = self.tile.full(core) {
            r.clear_all_99();

            for col in 0..9 {
                let x = 1 + col as i32 * 8;

                // Pile
                if let Some(card) = self.state.pile[col].peek_last() {
                    if col == 0 {
                        // Facedown pile
                        draw::card_back(&mut r, 0, x);
                    } else {
                        draw::card(&mut r, 0, x, card);
                    }
                } else {
                    draw::card_space(&mut r, 0, x);
                }

                // Index number
                r.hfb(7)
                    .at(CARD_SY, x)
                    .hfb(70)
                    .char((49 + col as u8) as char);

                // Stack
                let y0 = CARD_SY + 1;
                let y1 = r.sy();
                let hand = &self.state.stack[col];
                draw::card_space(&mut r, y0, x);

                let selected = self
                    .select
                    .map(|(index, count)| if col == index { count } else { 0 })
                    .unwrap_or(0);
                let len = hand.len();
                let sel_i = len.saturating_sub(selected);
                let space = y1 - y0 - 1;
                let mut y = y0;
                let mut i = 0;
                if len as i32 + CARD_SY > space {
                    draw::card_dots(&mut r, y, x);
                    y += 1;
                    i = len - (space - CARD_SY) as usize;
                }
                while i < hand.len() {
                    let card = hand[i];
                    if i >= sel_i {
                        draw::card(&mut r, y + 1, x + 1, card);
                    } else {
                        draw::card(&mut r, y, x, card);
                    }
                    i += 1;
                    y += 1;
                }
            }
        }
    }

pub fn spaces(&mut self, n: i32) -> &mut Self

Add N spaces to the region.

pub fn repl_char(&mut self) -> &mut Self

Add the Unicode replacement character U+FFFD

pub fn origin(&mut self) -> &mut Self

Move write position to the region top-left

pub fn skip(&mut self, n: i32) -> &mut Self

Skip the write position N cells forwards without overwriting any characters

Examples found in repository

examples/test2.rs (line 127)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

pub fn newline(&mut self) -> &mut Self

Move write position to the start of the next row. Note that writing a full line leaves the write position just past the end of the line, but not on the next line, so calling this method correctly moves to the next line in that case.

pub fn clear_all_99(&mut self) -> &mut Self

Clear the whole region to the default colour-pair (99). The write position is set to top-left, and the current colour is set to 99.

Examples found in repository

examples/teeclub/main.rs (line 128)

    fn redraw(&mut self, cx: CX![]) {
        let Some(ref tsh) = self.tsh else {
            return;
        };
        let mut tile = tsh.tile(cx);
        if let Some(mut r) = tile.full(cx) {
            r.clear_all_99();
        }
        after!(Duration::from_millis(10), [cx], layout());
    }

    fn layout(&mut self, cx: CX![]) {
        let Some(ref tsh) = self.tsh else {
            return;
        };

        let mut tile = tsh.tile(cx);
        if let Some(mut r) = tile.full(cx) {
            r.clear_all_99();
        }
        let left_gap = 0.max(tile.sx() - 80) / 2;
        let right_off = (left_gap + 80).min(tile.sx());
        let right_gap = tile.sx() - right_off;
        self.adjust = self.adjust.max(-left_gap).min(right_gap);
        let left_gap = left_gap + self.adjust;
        let right_off = (left_gap + 80).min(tile.sx());

        let (_, mid, _) = tile.split_xx(left_gap, right_off);
        let (main, scores) = mid.split_x(74);
        self.scores_tile = scores;
        let sy = main.sy();
        if let Some(game) = &mut self.game {
            game.layout(cx, main);
        } else {
            let logo_sy = 9;
            let instr_sy = 16;
            let gap = (sy - logo_sy - instr_sy) / 3;
            let (_, mut logo, rest) = main.split_yy(gap, gap + logo_sy);
            let (_, mut text, _) = rest.split_yy(gap, gap + instr_sy);
            if let Some(r) = logo.full(cx) {
                self.draw_logo(r);
            }
            if let Some(r) = text.full(cx) {
                Self::draw_instructions(r);
            }
        }

        self.draw_scores(cx);
    }

    fn draw_scores(&mut self, cx: CX![]) {
        let mut score = self.score;
        let mut last_score = self.last_score;
        if let Some(mut r) = self.scores_tile.full(cx) {
            r.hfb(176).clear_all();
            r.hfb(7).text("SCORES");
            let mut y = 1;
            let last_y = r.sy() - 1;
            let mut draw = move |hfb, sc| {
                if y > 0 {
                    r.at(y, 0).hfb(hfb);
                    write!(r, "{:3}:{:02}", sc / 60, sc % 60).unwrap();
                    y += 1;
                }
            };

            for &s0 in &self.scores {
                if let Some(curr) = score
                    && (curr < s0 || y == last_y)
                {
                    draw(7, curr);
                    score = None;
                }
                if Some(s0) == last_score {
                    draw(173, s0);
                    last_score = None;
                } else {
                    draw(176, s0);
                }
            }
            if let Some(s1) = score {
                draw(173, s1);
            }
        }
    }

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

    fn draw_instructions(mut r: Region<'_>) {
        const TEXT: &str = r"

        Keys: [N] New game; [Q] Quit; [1] to [9] Select cards in
        corresponding column; [+]/[=] or [-] Increase or decrease
        number of selected cards; [1] to [9] If the same digit as the
        selecting keypress, move selected cards to top, if another
        digit, move as many of selected cards as possible to that
        column; [Space] Bring a new card down from the stock pile;
        [BackSp] Go back one move; [<]/[>] Adjust display left/right.

        Rules: The aim is to move all the cards to the top area, the
        spaces the the right of the stock pile.  Each top pile must
        consist of one suit only, stacked in order from Ace up to
        King.  The cards in the main area can be moved around:
        sequences of one or more cards of the same suit may be moved
        on top of a card with the next-higher number, of any suit.
        The bulk of the cards are in the stock pile in the top-left.
        Cards may be brought down from there using Space.

        ";
        let lines: Vec<_> = TEXT.trim().split('\n').map(|s| s.to_string()).collect();
        let n_lines = lines.len();
        let oy = (r.sy() - n_lines as i32) / 2;
        for (i, line) in lines.iter().enumerate() {
            r.at(i as i32 + oy, 7);
            let line = line.trim().replace("[", "\0171 ").replace("]", " \0099");
            r.text(&line);
        }
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Pr('q' | 'Q') => {
                if self.game.is_some() {
                    self.game = None;
                    self.score = None;
                    self.layout(cx);
                } else {
                    stop!(cx);
                }
            }
            Key::Pr('n' | 'N') => {
                self.game = Some(Game::new(
                    cx.now(),
                    ret_some_to!([cx], game_finished() as (Duration)),
                ));
                self.last_score = None;
                self.update_score(cx);
                self.layout(cx);
            }
            Key::Pr('<') => {
                self.adjust -= 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            Key::Pr('>') => {
                self.adjust += 1;
                self.save_scores().expect("Failed to save scores");
                self.layout(cx);
            }
            _ => {
                if let Some(game) = &mut self.game {
                    game.input(cx, key);
                }
            }
        }
    }

    fn update_score(&mut self, cx: CX![]) {
        if let Some(game) = &mut self.game {
            let dur = game.score(cx);
            let score = dur.as_secs() as i32;
            let to_wait = if Some(score) != self.score {
                self.score = Some(score);
                self.draw_scores(cx);

                // Update 100ms after next change
                1_000_000_000 - dur.subsec_nanos() + 100_000_000
            } else {
                1_000_000_000
            };
            after!(Duration::from_nanos(to_wait as u64), [cx], update_score());
        }
    }

    fn game_finished(&mut self, cx: CX![], dur: Duration) {
        let score = dur.as_secs() as i32;
        self.scores.push(score);
        self.scores.sort_unstable();
        self.save_scores().expect("Failed to save scores");
        self.last_score = Some(score);
        self.score = None;
        self.game = None;
        self.layout(cx);
    }

    fn score_path() -> PathBuf {
        let mut path = std::env::home_dir().unwrap_or_default();
        path.push(".teeclub-scores");
        path
    }

    fn load_scores(&mut self) -> Option<()> {
        let data = std::fs::read_to_string(Self::score_path()).ok()?;
        let mut it = data.split(char::is_whitespace);
        while let Some(tok) = it.next() {
            match tok {
                "adjust:" => {
                    self.adjust = it.next()?.parse::<i32>().ok()?;
                }
                "scores[" => {
                    self.scores = Vec::new();
                    loop {
                        match it.next()? {
                            "]" => break,
                            v => self.scores.push(v.parse::<i32>().ok()?),
                        }
                    }
                    self.scores.sort_unstable();
                }
                "" => (),
                _ => return None,
            }
        }
        Some(())
    }

    fn save_scores(&mut self) -> std::io::Result<()> {
        let mut out = Vec::new();
        let _ = writeln!(out, "adjust: {}", self.adjust);
        let _ = writeln!(out, "scores[");
        for sc in self.scores.iter().take(200) {
            let _ = writeln!(out, "{sc}");
        }
        let _ = writeln!(out, "]");
        std::fs::write(Self::score_path(), out)
    }
}

/// Game state
#[derive(Eq, PartialEq)]
struct State {
    pile: [Hand; 9],
    stack: [Hand; 9],
}

impl State {
    fn pack(&self) -> Vec<u8> {
        let mut out = Vec::new();
        for p in &self.pile {
            p.pack(&mut out);
        }
        for s in &self.stack {
            s.pack(&mut out);
        }
        out
    }

    fn unpack(mut data: &[u8]) -> Self {
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();
        for p in &mut pile {
            *p = Hand::unpack(&mut data);
        }
        for s in &mut stack {
            *s = Hand::unpack(&mut data);
        }
        Self { pile, stack }
    }
}

/// Game state and gameplay handling
struct Game {
    tile: Tile,
    history: Vec<Vec<u8>>,
    state: State,
    select: Option<(usize, usize)>, // (index, count)
    dur: Duration,
    activity: Instant,
    ret: Option<Ret<Duration>>, // Report score for game completion
}

impl Game {
    fn new(start: Instant, ret: Ret<Duration>) -> Self {
        let seed = std::time::SystemTime::UNIX_EPOCH
            .elapsed()
            .map(|d| d.as_nanos() as u64)
            .unwrap_or(0);

        let mut rand = Rand32::new(seed);
        let mut pile: [Hand; 9] = Default::default();
        let mut stack: [Hand; 9] = Default::default();

        let p0 = &mut pile[0];
        p0.add_deck();
        p0.add_deck();
        p0.shuffle(&mut rand);
        p0.shuffle(&mut rand);

        for _ in 0..5 {
            for s in &mut stack {
                if let Some(card) = p0.pick_last() {
                    s.add(card);
                }
            }
        }

        Self {
            tile: Tile::default(),
            history: Vec::new(),
            state: State { pile, stack },
            select: None,
            dur: Duration::from_secs(0),
            activity: start,
            ret: Some(ret),
        }
    }

    fn select(&mut self, core: &mut Core, i: usize) {
        let s = &self.state.stack[i];
        let len = s.len();
        if len == 0 {
            self.select = None;
        } else {
            let mut count = 1;
            while count < len && s[len - count].inc == Some(s[len - count - 1]) {
                count += 1;
            }
            self.select = Some((i, count));
        }
        self.draw(core);
    }

    fn sel_inc(&mut self, core: &mut Core) {
        if let Some((i, count)) = self.select {
            let s = &self.state.stack[i];
            let len = s.len();
            if count < len && s[len - count].inc == Some(s[len - count - 1]) {
                self.select = Some((i, count + 1));
                self.draw(core);
            }
        }
    }

    fn sel_dec(&mut self, core: &mut Core) {
        if let Some(sel) = &mut self.select {
            let i = sel.0;
            let count = sel.1;
            if count <= 1 {
                self.select = None;
            } else {
                self.select = Some((i, count - 1));
            }
            self.draw(core);
        }
    }

    /// Mark this state by saving it in history, available to undo
    /// later
    fn mark(&mut self) {
        let v = self.state.pack();
        if let Some(last) = self.history.last()
            && *last == v
        {
            return;
        }
        self.history.push(v);
    }

    /// Restore most recent marked state and remove it from history
    fn undo(&mut self, core: &mut Core) {
        if let Some(data) = self.history.pop() {
            self.state = State::unpack(&data);
            self.select = None;
            self.draw(core);
        }
    }

    /// Move selected cards to the given stack or to top if the stack
    /// is the selected stack
    fn move_to(&mut self, core: &mut Core, to: usize) {
        let Some((fr, cnt)) = self.select else {
            return;
        };
        self.select = None;
        self.mark();

        let s = &mut self.state;
        let Some(fr_last) = s.stack[fr].peek_last() else {
            return;
        };

        if fr == to {
            // Move to top
            for pi in (1..9).rev() {
                let do_move = if let Some(to_last) = s.pile[pi].peek_last() {
                    to_last.inc == Some(fr_last)
                } else {
                    fr_last.num == 1
                };
                if do_move {
                    for _ in 0..cnt {
                        if let Some(card) = s.stack[fr].pick_last() {
                            s.pile[pi].add(card);
                        }
                    }
                    break;
                }
            }
            if self.is_finished()
                && let Some(ret) = self.ret.take()
            {
                ret!([ret], self.score(core));
            }
        } else {
            // Move to another pile
            let mut copy_cnt = cnt;
            if let Some(to_last) = s.stack[to].peek_last() {
                copy_cnt = copy_cnt.min(to_last.num.saturating_sub(fr_last.num) as usize);
                if to_last.num != fr_last.num + copy_cnt as u8 {
                    copy_cnt = 0;
                }
            }

            let mut tmp = Vec::new();
            for _ in 0..copy_cnt {
                tmp.push(s.stack[fr].pick_last().unwrap());
            }
            while let Some(card) = tmp.pop() {
                s.stack[to].add(card);
            }
        }
        self.draw(core);
    }

    /// Move card down from stock pile
    fn move_down(&mut self, core: &mut Core) {
        self.mark();
        if let Some(card) = self.state.pile[0].pick_last() {
            self.state.stack[0].add(card);
            self.select = None;
            self.draw(core);
        }
    }

    fn is_finished(&mut self) -> bool {
        for i in 1..9 {
            if self.state.pile[i].len() != 13 {
                return false;
            }
        }
        true
    }

    /// Set the tile to use for drawing, and redraw
    fn layout(&mut self, core: &mut Core, tile: Tile) {
        self.tile = tile;
        self.draw(core);
    }

    /// Draw the playing area
    fn draw(&mut self, core: &mut Core) {
        if let Some(mut r) = self.tile.full(core) {
            r.clear_all_99();

            for col in 0..9 {
                let x = 1 + col as i32 * 8;

                // Pile
                if let Some(card) = self.state.pile[col].peek_last() {
                    if col == 0 {
                        // Facedown pile
                        draw::card_back(&mut r, 0, x);
                    } else {
                        draw::card(&mut r, 0, x, card);
                    }
                } else {
                    draw::card_space(&mut r, 0, x);
                }

                // Index number
                r.hfb(7)
                    .at(CARD_SY, x)
                    .hfb(70)
                    .char((49 + col as u8) as char);

                // Stack
                let y0 = CARD_SY + 1;
                let y1 = r.sy();
                let hand = &self.state.stack[col];
                draw::card_space(&mut r, y0, x);

                let selected = self
                    .select
                    .map(|(index, count)| if col == index { count } else { 0 })
                    .unwrap_or(0);
                let len = hand.len();
                let sel_i = len.saturating_sub(selected);
                let space = y1 - y0 - 1;
                let mut y = y0;
                let mut i = 0;
                if len as i32 + CARD_SY > space {
                    draw::card_dots(&mut r, y, x);
                    y += 1;
                    i = len - (space - CARD_SY) as usize;
                }
                while i < hand.len() {
                    let card = hand[i];
                    if i >= sel_i {
                        draw::card(&mut r, y + 1, x + 1, card);
                    } else {
                        draw::card(&mut r, y, x, card);
                    }
                    i += 1;
                    y += 1;
                }
            }
        }
    }

examples/test2.rs (line 104)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

examples/fontedit/app.rs (line 171)

    fn draw_cells(&mut self, cx: CX![]) {
        if let Some(mut full) = self.cells_tile.full(cx) {
            let sx = full.sx();
            full.clear_all_99();

            let font_sx = self.font.sx;
            let font_sy = self.font.sy;
            let cell_wid = font_sx * 2;
            let r = full.region(
                0,
                (sx - cell_wid as i32) / 2,
                font_sy as i32,
                cell_wid as i32,
            );
            draw_cell(
                &self.font,
                r,
                self.index,
                171,
                7,
                Some((self.cy, self.cx, self.mode)),
            );
            let max = self.font.index_limit();
            for i in 1..=self.index {
                let r = full.region(
                    0,
                    (sx - (cell_wid * (1 + i * 2)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index - i, 70, 6, None);
            }
            for i in 1..(max - self.index) {
                let r = full.region(
                    0,
                    (sx + (cell_wid * (i * 2 - 1)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index + i, 70, 6, None);
            }
        }
    }

    fn draw_mini(&mut self, cx: CX![]) {
        if let Some(mut full) = self.mini_tile.full(cx) {
            full.clear_all_99();
            let sx = full.sx() * 2;
            let sy = full.sy() * 4;
            let font_sx = self.font.sx as i32;
            let font_sy = self.font.sy as i32;
            let oy = sy.saturating_sub(font_sy) / 2;
            let mut ox = (sx - font_sx) / 2;
            let mut index = self.index;
            while ox > 0 && index > 0 {
                ox -= font_sx;
                index -= 1;
            }
            while ox < sx {
                draw_mini_cell(&self.font, full.full(), oy, ox, index, 170);
                ox += font_sx;
                index += 1;
            }
        }
    }

pub fn clear_all(&mut self) -> &mut Self

Clear the whole region to space characters of the current hfb colour-pair. This will be clipped according to the current and parent regions. The write position is set to top-left, and the current colour is set to hfb.

Examples found in repository

examples/teeclub/draw.rs (line 11)

pub fn card(r: &mut Region, y: i32, x: i32, card: Card) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(card.hfb).clear_all();
    r.at(0, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
    r.at(CARD_SY - 1, 2);
    write!(r, "{}{}", card.num_ch, card.suit_ch).unwrap();
}

/// Draw the back of a card
pub fn card_back(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(27);
    for y in 0..CARD_SY {
        r.at(y, 0).text("||||||");
    }
}

/// Draw the space where a card could go
pub fn card_space(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(71).clear_all();
}

examples/teeclub/main.rs (line 176)

    fn draw_scores(&mut self, cx: CX![]) {
        let mut score = self.score;
        let mut last_score = self.last_score;
        if let Some(mut r) = self.scores_tile.full(cx) {
            r.hfb(176).clear_all();
            r.hfb(7).text("SCORES");
            let mut y = 1;
            let last_y = r.sy() - 1;
            let mut draw = move |hfb, sc| {
                if y > 0 {
                    r.at(y, 0).hfb(hfb);
                    write!(r, "{:3}:{:02}", sc / 60, sc % 60).unwrap();
                    y += 1;
                }
            };

            for &s0 in &self.scores {
                if let Some(curr) = score
                    && (curr < s0 || y == last_y)
                {
                    draw(7, curr);
                    score = None;
                }
                if Some(s0) == last_score {
                    draw(173, s0);
                    last_score = None;
                } else {
                    draw(176, s0);
                }
            }
            if let Some(s1) = score {
                draw(173, s1);
            }
        }
    }

examples/fontedit/app.rs (line 109)

    fn redraw(&mut self, cx: CX![]) {
        if let Some(ref tsh) = self.tsh {
            let out = tsh.output(cx);
            out.attr_99().cursor_show().scroll_up().save_cleanup();
            out.cursor_hide().clear_all_99_and_remote();

            // Draw fixed stuff here, then break out and store
            // sub-tiles for areas that need to be updated later
            let tile = tsh.tile(cx);
            let sx = tile.sx();
            let sy = tile.sy();
            let split_y1 = sy - self.font.sy as i32;
            let split_y0 = split_y1.min(10);
            let (top, _, cells_tile) = tile.split_yy(split_y0, split_y1);
            let spare = sx.saturating_sub(80);
            let (ox, mini_sx) = if (spare as usize) < self.font.sx / 2 {
                (spare / 2, 0)
            } else {
                (0, spare)
            };
            let (_, rest) = top.split_x(ox);
            let (param_tile, mini_tile, mut keys_tile) = rest.split_xx(40, 40 + mini_sx);

            if let Some(mut r) = keys_tile.region(cx, 0, 0, split_y0, 40) {
                r.hfb(172).clear_all();
                let text = "\
Keys: Arrows move, [Space] change pixel
Mode on/off: [d] draw, [r] roll
Fill: [f] flood, [v] vert, [h] horiz
[n] new glyph, [u] undo, [l] ruler line
Clip: [c] copy, [P] paste.
Index: [PgUp] [PgDn] [Home] [End].
[S] save, [Q] save+quit, [^C] hard quit
Edit the font file directly to change
font size or codepoint numbers.";
                r.text(&text.replace('[', "\0171 ").replace(']', " \0172"));
            }
            self.cells_tile = cells_tile;
            self.param_tile = param_tile;
            self.mini_tile = mini_tile;

            self.draw_cells(cx);
            self.draw_mini(cx);
            self.draw_param(cx);
        }
    }

    fn draw_param(&mut self, cx: CX![]) {
        if let Some(mut r) = self.param_tile.full(cx) {
            r.hfb(172).clear_all();

            // Use sub-region to clip the filename if it's too long
            r.region(0, 0, 1, 39)
                .hfb(172)
                .text("File:  ")
                .text(&self.font.path.to_string_lossy());

            let count = self.font.index_limit();
            let index = self.index;

            let state = if let Some(ref err) = self.save_error {
                err
            } else if self.unsaved {
                "UNSAVED"
            } else {
                ""
            };
            let cp = self.font.chars[index].cp;
            let ch = match cp {
                32..=126 | 160.. => char::from_u32(cp).unwrap_or('?'),
                _ => '?',
            };
            let sx = self.font.sx;
            let sy = self.font.sy;

            r.at(1, 0);
            let _ = writeln!(r, "Size:  {sx} x {sy}, {count} glyphs");
            let _ = writeln!(r, "Index: {index} U+{cp:04x} '{ch}'");
            let _ = writeln!(r, "Mode:  {}", self.mode.caps());
            let _ = writeln!(r, "State: {}", state);
        }
    }

pub fn clear_eol_99(&mut self) -> &mut Self

Clear to end-of-line with the default colour-pair. Leaves the current colour-pair set to 99.

pub fn clear_eol(&mut self) -> &mut Self

Clear to end-of-line with the current colour-pair.

pub fn text(&mut self, text: &str) -> &mut Self

Write some text at the current location with the current HFB, wrapping to the start of the next line at each row-end of the region. What is actually output to the page will be clipped according to all current and parent regions. Interprets \0ZZZ colour sequences to change the current HFB. Interprets \n.

Note that even if the text is partially or fully outside the clip region, the write position will still be advanced correctly.

Examples found in repository

examples/teeclub/draw.rs (line 23)

pub fn card_back(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(27);
    for y in 0..CARD_SY {
        r.at(y, 0).text("||||||");
    }
}

/// Draw the space where a card could go
pub fn card_space(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(71).clear_all();
}

/// Draw "more cards" indicator
pub fn card_dots(r: &mut Region, y: i32, x: i32) {
    let mut r = r.region(y, x, CARD_SY, CARD_SX);
    r.hfb(70);
    for y in 0..CARD_SY {
        r.at(y, 0).text("::::::");
    }
}

examples/teeclub/main.rs (line 177)

    fn draw_scores(&mut self, cx: CX![]) {
        let mut score = self.score;
        let mut last_score = self.last_score;
        if let Some(mut r) = self.scores_tile.full(cx) {
            r.hfb(176).clear_all();
            r.hfb(7).text("SCORES");
            let mut y = 1;
            let last_y = r.sy() - 1;
            let mut draw = move |hfb, sc| {
                if y > 0 {
                    r.at(y, 0).hfb(hfb);
                    write!(r, "{:3}:{:02}", sc / 60, sc % 60).unwrap();
                    y += 1;
                }
            };

            for &s0 in &self.scores {
                if let Some(curr) = score
                    && (curr < s0 || y == last_y)
                {
                    draw(7, curr);
                    score = None;
                }
                if Some(s0) == last_score {
                    draw(173, s0);
                    last_score = None;
                } else {
                    draw(176, s0);
                }
            }
            if let Some(s1) = score {
                draw(173, s1);
            }
        }
    }

    fn draw_logo(&self, mut r: Region<'_>) {
        const LOGO_HFB: [u16; 30] = [
            160, 160, 160, 140, 140, 140, 140, 140, 150, 150, 150, 150, 150, 110, 110, 110, 110,
            110, 130, 130, 130, 130, 130, 120, 120, 120, 120, 120, 160, 160,
        ];
        const LOGO: [&str; 9] = [
            r"  ___________________________________      ",
            r" / ____  ____________________________\     ",
            r"/ /   / /                __      __  __    ",
            r"\ \  / / ___  ___  _____/ /_  __/ /_ \ \   ",
            r" \/ / / / _ \/ _ \/ ___/ / / / / __ \ \ \  ",
            r"   / / /  __/  __/ /__/ / /_/ / /_/ /  \ \ ",
            r"   \_\ \___/\___/\___/_/\__,_/_.___/ /_ \ \",
            r"     ___________________________________/ /",
            r"     \___________________________________/ ",
        ];
        let logo_hfb = match self.logo_hfb.as_ref() {
            Some(v) => v.as_slice(),
            None => LOGO_HFB.as_slice(),
        };
        let ox = (r.sx() - 43) / 2;
        let oy = (r.sy() - 9) / 2;
        for (y, s) in LOGO.iter().enumerate() {
            r.at(oy + y as i32, ox);
            for (x, c) in s.chars().enumerate() {
                r.hfb(logo_hfb[(10 + x + y) % 30]);
                r.char(c);
            }
        }
    }

    fn draw_instructions(mut r: Region<'_>) {
        const TEXT: &str = r"

        Keys: [N] New game; [Q] Quit; [1] to [9] Select cards in
        corresponding column; [+]/[=] or [-] Increase or decrease
        number of selected cards; [1] to [9] If the same digit as the
        selecting keypress, move selected cards to top, if another
        digit, move as many of selected cards as possible to that
        column; [Space] Bring a new card down from the stock pile;
        [BackSp] Go back one move; [<]/[>] Adjust display left/right.

        Rules: The aim is to move all the cards to the top area, the
        spaces the the right of the stock pile.  Each top pile must
        consist of one suit only, stacked in order from Ace up to
        King.  The cards in the main area can be moved around:
        sequences of one or more cards of the same suit may be moved
        on top of a card with the next-higher number, of any suit.
        The bulk of the cards are in the stock pile in the top-left.
        Cards may be brought down from there using Space.

        ";
        let lines: Vec<_> = TEXT.trim().split('\n').map(|s| s.to_string()).collect();
        let n_lines = lines.len();
        let oy = (r.sy() - n_lines as i32) / 2;
        for (i, line) in lines.iter().enumerate() {
            r.at(i as i32 + oy, 7);
            let line = line.trim().replace("[", "\0171 ").replace("]", " \0099");
            r.text(&line);
        }
    }

examples/test2.rs (line 117)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

examples/fontedit/app.rs (line 120)

    fn redraw(&mut self, cx: CX![]) {
        if let Some(ref tsh) = self.tsh {
            let out = tsh.output(cx);
            out.attr_99().cursor_show().scroll_up().save_cleanup();
            out.cursor_hide().clear_all_99_and_remote();

            // Draw fixed stuff here, then break out and store
            // sub-tiles for areas that need to be updated later
            let tile = tsh.tile(cx);
            let sx = tile.sx();
            let sy = tile.sy();
            let split_y1 = sy - self.font.sy as i32;
            let split_y0 = split_y1.min(10);
            let (top, _, cells_tile) = tile.split_yy(split_y0, split_y1);
            let spare = sx.saturating_sub(80);
            let (ox, mini_sx) = if (spare as usize) < self.font.sx / 2 {
                (spare / 2, 0)
            } else {
                (0, spare)
            };
            let (_, rest) = top.split_x(ox);
            let (param_tile, mini_tile, mut keys_tile) = rest.split_xx(40, 40 + mini_sx);

            if let Some(mut r) = keys_tile.region(cx, 0, 0, split_y0, 40) {
                r.hfb(172).clear_all();
                let text = "\
Keys: Arrows move, [Space] change pixel
Mode on/off: [d] draw, [r] roll
Fill: [f] flood, [v] vert, [h] horiz
[n] new glyph, [u] undo, [l] ruler line
Clip: [c] copy, [P] paste.
Index: [PgUp] [PgDn] [Home] [End].
[S] save, [Q] save+quit, [^C] hard quit
Edit the font file directly to change
font size or codepoint numbers.";
                r.text(&text.replace('[', "\0171 ").replace(']', " \0172"));
            }
            self.cells_tile = cells_tile;
            self.param_tile = param_tile;
            self.mini_tile = mini_tile;

            self.draw_cells(cx);
            self.draw_mini(cx);
            self.draw_param(cx);
        }
    }

    fn draw_param(&mut self, cx: CX![]) {
        if let Some(mut r) = self.param_tile.full(cx) {
            r.hfb(172).clear_all();

            // Use sub-region to clip the filename if it's too long
            r.region(0, 0, 1, 39)
                .hfb(172)
                .text("File:  ")
                .text(&self.font.path.to_string_lossy());

            let count = self.font.index_limit();
            let index = self.index;

            let state = if let Some(ref err) = self.save_error {
                err
            } else if self.unsaved {
                "UNSAVED"
            } else {
                ""
            };
            let cp = self.font.chars[index].cp;
            let ch = match cp {
                32..=126 | 160.. => char::from_u32(cp).unwrap_or('?'),
                _ => '?',
            };
            let sx = self.font.sx;
            let sy = self.font.sy;

            r.at(1, 0);
            let _ = writeln!(r, "Size:  {sx} x {sy}, {count} glyphs");
            let _ = writeln!(r, "Index: {index} U+{cp:04x} '{ch}'");
            let _ = writeln!(r, "Mode:  {}", self.mode.caps());
            let _ = writeln!(r, "State: {}", state);
        }
    }

    fn draw_cells(&mut self, cx: CX![]) {
        if let Some(mut full) = self.cells_tile.full(cx) {
            let sx = full.sx();
            full.clear_all_99();

            let font_sx = self.font.sx;
            let font_sy = self.font.sy;
            let cell_wid = font_sx * 2;
            let r = full.region(
                0,
                (sx - cell_wid as i32) / 2,
                font_sy as i32,
                cell_wid as i32,
            );
            draw_cell(
                &self.font,
                r,
                self.index,
                171,
                7,
                Some((self.cy, self.cx, self.mode)),
            );
            let max = self.font.index_limit();
            for i in 1..=self.index {
                let r = full.region(
                    0,
                    (sx - (cell_wid * (1 + i * 2)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index - i, 70, 6, None);
            }
            for i in 1..(max - self.index) {
                let r = full.region(
                    0,
                    (sx + (cell_wid * (i * 2 - 1)) as i32) / 2,
                    font_sy as i32,
                    cell_wid as i32,
                );
                if !r.is_visible() {
                    break;
                }
                draw_cell(&self.font, r, self.index + i, 70, 6, None);
            }
        }
    }

    fn draw_mini(&mut self, cx: CX![]) {
        if let Some(mut full) = self.mini_tile.full(cx) {
            full.clear_all_99();
            let sx = full.sx() * 2;
            let sy = full.sy() * 4;
            let font_sx = self.font.sx as i32;
            let font_sy = self.font.sy as i32;
            let oy = sy.saturating_sub(font_sy) / 2;
            let mut ox = (sx - font_sx) / 2;
            let mut index = self.index;
            while ox > 0 && index > 0 {
                ox -= font_sx;
                index -= 1;
            }
            while ox < sx {
                draw_mini_cell(&self.font, full.full(), oy, ox, index, 170);
                ox += font_sx;
                index += 1;
            }
        }
    }

    fn draw_all(&mut self, cx: CX![]) {
        self.draw_cells(cx);
        self.draw_mini(cx);
        self.draw_param(cx);
    }

    fn input(&mut self, cx: CX![], key: Key) {
        match key {
            Key::Ctrl('L') => self.redraw(cx),
            Key::Ctrl('C') => stop!(cx),
            Key::Left => {
                if self.cx > 0 {
                    self.move_or_draw(cx, 0, -1)
                }
            }
            Key::Right => {
                if self.cx + 1 < self.font.sx {
                    self.move_or_draw(cx, 0, 1)
                }
            }
            Key::Up => {
                if self.cy > 0 {
                    self.move_or_draw(cx, -1, 0)
                }
            }
            Key::Down => {
                if self.cy + 1 < self.font.sy {
                    self.move_or_draw(cx, 1, 0)
                }
            }
            Key::PgUp => {
                if self.index > 0 {
                    self.index -= 1;
                    self.draw_all(cx);
                }
            }
            Key::PgDn => {
                if self.index + 1 < self.font.index_limit() {
                    self.index += 1;
                    self.draw_all(cx);
                }
            }
            Key::Home => {
                self.index = 0;
                self.draw_all(cx);
            }
            Key::End => {
                self.index = self.font.index_limit() - 1;
                self.draw_all(cx);
            }
            Key::Pr(' ') => {
                self.undo_push();
                self.unsaved = true;
                let curr = self.font.get(self.index, self.cy, self.cx);
                self.font.set(self.index, self.cy, self.cx, !curr);
                self.draw_all(cx);
            }
            Key::Pr('d') => {
                self.mode = match self.mode {
                    Mode::Draw => Mode::Move,
                    _ => Mode::Draw,
                };
                self.draw_all(cx);
            }
            Key::Pr('r') => {
                self.mode = match self.mode {
                    Mode::Roll => Mode::Move,
                    _ => Mode::Roll,
                };
                self.draw_all(cx);
            }
            Key::Pr('f') => {
                self.undo_push();
                self.unsaved = true;
                self.font.fill(self.index, self.cy, self.cx, true, true);
                self.draw_all(cx);
            }
            Key::Pr('h') => {
                self.undo_push();
                self.unsaved = true;
                self.font.fill(self.index, self.cy, self.cx, false, true);
                self.draw_all(cx);
            }
            Key::Pr('v') => {
                self.undo_push();
                self.unsaved = true;
                self.font.fill(self.index, self.cy, self.cx, true, false);
                self.draw_all(cx);
            }
            Key::Pr('u') => {
                if let Some(font) = self.undo.pop_front() {
                    self.font = font;
                    let limit = self.font.index_limit();
                    self.index = self.index.min(limit - 1);
                    self.draw_all(cx);
                }
            }
            Key::Pr('l') => {
                self.font.rule_bm ^= 1 << self.cy;
                self.unsaved = true;
                self.draw_all(cx);
            }
            Key::Pr('n') => {
                self.undo_push();
                self.unsaved = true;
                self.index = self.font.index_limit();
                self.font.add_glyph();
                self.draw_param(cx);
                self.draw_cells(cx);
            }
            Key::Pr('c') => {
                self.clip = self.font.get_glyph(self.index);
            }
            Key::Pr('P') => {
                if !self.clip.is_empty() {
                    self.undo_push();
                    self.unsaved = true;
                    self.font.set_glyph(self.index, &self.clip);
                    self.draw_all(cx);
                }
            }
            Key::Pr('S') => {
                if let Err(e) = self.font.save() {
                    self.save_error = Some(e.to_string());
                } else {
                    self.save_error = None;
                    self.unsaved = false;
                }
                self.draw_param(cx);
            }
            Key::Pr('Q') => {
                if let Err(e) = self.font.save() {
                    fail!(cx, e);
                } else {
                    stop!(cx);
                }
            }
            _ => call!([self.term], bell()),
        }
    }

    fn move_or_draw(&mut self, cx: CX![], dy: i32, dx: i32) {
        match self.mode {
            Mode::Move => {
                self.cx = (self.cx as i32 + dx) as usize;
                self.cy = (self.cy as i32 + dy) as usize;
                self.draw_cells(cx);
            }
            Mode::Draw => {
                self.undo_push();
                self.unsaved = true;
                let curr = self.font.get(self.index, self.cy, self.cx);
                self.cx = (self.cx as i32 + dx) as usize;
                self.cy = (self.cy as i32 + dy) as usize;
                self.font.set(self.index, self.cy, self.cx, curr);
                self.draw_all(cx);
            }
            Mode::Roll => {
                self.undo_push();
                if dx != 0 {
                    self.font.roll_horiz(self.index, dx);
                }
                if dy != 0 {
                    self.font.roll_vert(self.index, dy);
                }
                self.draw_all(cx);
            }
        }
    }

    fn undo_push(&mut self) {
        self.undo.push_front(self.font.clone());
        while self.undo.len() > 50 {
            self.undo.pop_back();
        }
    }
}

fn draw_cell(
    font: &Font,
    mut r: Region,
    index: usize,
    black: u16,
    white: u16,
    curs: Option<(usize, usize, Mode)>,
) {
    let form = &font.chars[index].form;
    for y in 0..font.sy {
        let rule = ((font.rule_bm >> y) & 1) != 0;
        for x in 0..font.sx {
            r.hfb(if form[x + y * font.sx] { white } else { black });
            let mut text = if rule { "--" } else { "  " };
            if let Some((cy, cx, mode)) = curs
                && cy == y
                && cx == x
            {
                text = mode.cursor();
            }
            r.text(text);
        }
    }
}

pub fn bytes(&mut self, text: &[u8]) -> &mut Self

Write some text (expressed as bytes of UTF-8) at the current location with the current HFB, wrapping to the start of the next line at each row-end of the region. What is actually output to the page will be clipped according to all current and parent regions. Interprets \0ZZZ colour sequences to change the current HFB. Interprets \n.

Note that even if the text is partially or fully outside the clip region, the write position will still be advanced correctly.

pub fn get(&mut self, y: i32, x: i32) -> Option<(u16, &[u8])>

Get the contents of the cell at the given location relative to the region’s top-left. Returns None if the location is outside the region’s clip. Otherwise returns Some((hfb, data)) where data is the UTF-8 data of the cell. Note that in the case of a double-width character, the data will be prefixed with an 0xFF byte in the left cell, and will contain an 0xFE byte alone in the right cell.

pub fn set_hfb(&mut self, y: i32, x: i32, hfb: u16)

Set the HFB colour of a cell without affecting the glyph. Location is relative to region top-left.

Examples found in repository

examples/test2.rs (line 132)

    fn redraw(&mut self, cx: CX![], full: bool) {
        let pg = &mut self.page;
        let sx = pg.sx();
        let sy = pg.sy();

        if sy < 24 || sx < 80 {
            let mut r = pg.full();
            r.clear_all_99();
            r.at(sy >> 1, (sx - 30) >> 1).hfb(162);
            write!(r, " Terminal too small: {sy} x {sx} ").unwrap();
            return;
        }

        const TEXT: &str = "This is a test.  ";
        const TEXTLEN: usize = TEXT.len();
        let mid = sx >> 1;
        for y in 0..sy {
            let mut r = pg.region(y, 0, 1, sx + TEXTLEN as i32 * 2);
            r.at(0, y % TEXTLEN as i32 - TEXTLEN as i32).hfb(99);
            while r.get_x() < sx {
                r.text(TEXT);
            }
            if self.spacing_on {
                let mut x = (sx + sy) / 2 - y;
                while x > 0 {
                    x -= self.spacing
                }
                r.at(0, x);
                while r.get_x() < sx {
                    r.text("/");
                    r.skip(self.spacing - 1);
                }
            }
            let shift = y * 6 / sy;
            for x in 0..sx {
                r.set_hfb(0, x, (((x - mid) >> shift) & 3) as u16 + 70);
            }
        }
        pg.full()
            .at(sy - 2, (sx - 40) >> 1)
            .hfb(6)
            .text("  PRESS ANY KEY TO CONTINUE, Ctrl-C TO END  ");

        self.update(cx, full);
    }

pub fn set(&mut self, y: i32, x: i32, hfb: u16, data: &[u8])

Set the HFB colour and UTF-8 glyph data of a cell. Location is relative to region top-left. For double-width glyphs, the left cell should contain byte 0xFF plus the UTF-8, and the right cell should contain only an 0xFE byte. If one or other half is missing, the incorrect cells will show as the replacement character.

pub fn braille_plot(&mut self, py: i32, px: i32, hfb: u16, set: bool)

Plot or unplot a point using Braille glyphs. Braille glyphs contain 2 points across and 4 down. They can be used for lo-res graphics. The total grid available to be addressed by (py, px) is 4*sy high and 2*sx wide. The only restriction is that the HFB colour-pair cannot be set independently for each point. Those apply at the glyph level. On plotting, if the point being plotted belongs to a non-Braille glyph, then that glyph is overwritten. If it is a Braille glyph then the point is added to it (set == true) or removed from it (set == false).

Examples found in repository

examples/fontedit/app.rs (line 449)

fn draw_mini_cell(font: &Font, mut r: Region, oy: i32, ox: i32, index: usize, hfb: u16) {
    if index < font.chars.len() {
        let form = &font.chars[index].form;
        for y in 0..font.sy {
            for x in 0..font.sx {
                if form[x + y * font.sx] {
                    r.braille_plot(oy + y as i32, ox + x as i32, hfb, true);
                }
            }
        }
    }
}

Trait Implementations

impl Debug for Region<'_>

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

Formats the value using the given formatter.

impl Write for Region<'_>

fn flush(&mut self) -> Result<()>

The data is considered already flushed as soon as it is written to the region.

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.