diff options
| author | Daniel Eklöf <daniel@ekloef.se> | 2019-06-29 19:03:28 +0000 |
|---|---|---|
| committer | Daniel Eklöf <daniel@ekloef.se> | 2019-06-29 19:03:28 +0000 |
| commit | 1ecd4a6ae14d951090b88a18972d55d81232eabf (patch) | |
| tree | 46f35ef6c9f7a592911484386b086dbac6f24f9a /terminal.c | |
| parent | render: don't try to render glyph for empty cell(s) (diff) | |
Rename grid_* functions to term_*
Diffstat (limited to 'terminal.c')
| -rw-r--r-- | terminal.c | 311 |
1 files changed, 311 insertions, 0 deletions
diff --git a/terminal.c b/terminal.c new file mode 100644 index 00000000..61e9d04c --- /dev/null +++ b/terminal.c @@ -0,0 +1,311 @@ +#include "terminal.h" + +#include <string.h> +#include <assert.h> + +#define LOG_MODULE "terminal" +#define LOG_ENABLE_DBG 1 +#include "log.h" + +#define min(x, y) ((x) < (y) ? (x) : (y)) +#define max(x, y) ((x) > (y) ? (x) : (y)) + +static bool +damage_merge_range(struct terminal *term, const struct damage *dmg) +{ + if (tll_length(term->grid.damage) == 0) + return false; + + struct damage *old = &tll_back(term->grid.damage); + if (old->type != dmg->type) + return false; + + const int start = dmg->range.start; + const int end = start + dmg->range.length; + + const int prev_start = old->range.start; + const int prev_end = prev_start + old->range.length; + + if ((start >= prev_start && start <= prev_end) || + (end >= prev_start && end <= prev_end) || + (start <= prev_start && end >= prev_end)) + { + /* The two damage ranges intersect */ + int new_start = min(start, prev_start); + int new_end = max(end, prev_end); + + old->range.start = new_start; + old->range.length = new_end - new_start; + + assert(old->range.start >= 0); + assert(old->range.start < term->grid.rows * term->grid.cols); + assert(old->range.length >= 0); + assert(old->range.start + old->range.length <= term->grid.rows * term->grid.cols); + return true; + } + + return false; +} + +static void +term_damage_update_or_erase(struct terminal *term, enum damage_type damage_type, + int start, int length) +{ + struct damage dmg = { + .type = damage_type, + .range = {.start = start, .length = length}, + }; + + assert(dmg.range.start >= 0); + assert(dmg.range.start < term->grid.rows * term->grid.cols); + assert(dmg.range.length >= 0); + assert(dmg.range.start + dmg.range.length <= term->grid.rows * term->grid.cols); + + if (damage_merge_range(term, &dmg)) + return; + + tll_push_back(term->grid.damage, dmg); +} + +void +term_damage_update(struct terminal *term, int start, int length) +{ + term_damage_update_or_erase(term, DAMAGE_UPDATE, start, length); +} + +void +term_damage_erase(struct terminal *term, int start, int length) +{ + term_damage_update_or_erase(term, DAMAGE_ERASE, start, length); +} + +void +term_damage_all(struct terminal *term) +{ + tll_free(term->grid.damage); + tll_free(term->grid.scroll_damage); + term_damage_update(term, 0, term->grid.rows * term->grid.cols); +} + +static void +damage_adjust_after_scroll(struct terminal *term, enum damage_type damage_type, + struct scroll_region region, int lines) +{ + const int adjustment + = lines * term->grid.cols * (damage_type == DAMAGE_SCROLL_REVERSE ? -1 : 1); + + const int scroll_start = region.start * term->grid.cols; + const int scroll_end = region.end * term->grid.cols; + + tll_foreach(term->grid.damage, it) { + int start = it->item.range.start; + int length = it->item.range.length; + int end = start + length; + + if (start < scroll_start && end > scroll_start) { + /* Start outside, end either inside or on the other side */ + struct damage outside = { + .type = it->item.type, + .range = {.start = start, .length = scroll_start - start}, + }; + + tll_push_back(term->grid.damage, outside); + start = scroll_start; + length = end - start; + + } + + if (start < scroll_end && end > scroll_end) { + /* End outside, start either inside or on the other side */ + struct damage outside = { + .type = it->item.type, + .range = {.start = scroll_end, .length = length - scroll_end}, + }; + + tll_push_back(term->grid.damage, outside); + end = scroll_end; + length = end - start; + } + + if (start >= scroll_start && end <= scroll_end) { + /* Completely inside scroll region */ + start -= adjustment; + it->item.range.start = start; + + if (start < scroll_start) { + /* Scrolled up outside scroll region */ + int new_length = length - (scroll_start - start); + assert(new_length < length); + + if (new_length <= 0) + tll_remove(term->grid.damage, it); + else { + it->item.range.start = scroll_start; + it->item.range.length = new_length; + } + } + + if (start + length > scroll_end) { + /* Scrolled down outside scroll region */ + if (start >= scroll_end) + tll_remove(term->grid.damage, it); + else { + it->item.range.start = start; + it->item.range.length = scroll_end - start; + } + } + } + } +} + +void +term_damage_scroll(struct terminal *term, enum damage_type damage_type, + struct scroll_region region, int lines) +{ + damage_adjust_after_scroll(term, damage_type, region, lines); + + if (tll_length(term->grid.scroll_damage) > 0) { + struct damage *dmg = &tll_back(term->grid.scroll_damage); + + if (dmg->type == damage_type && + dmg->scroll.region.start == region.start && + dmg->scroll.region.end == region.end) + { + dmg->scroll.lines += lines; + return; + } + } + struct damage dmg = { + .type = damage_type, + .scroll = {.region = region, .lines = lines}, + }; + tll_push_back(term->grid.scroll_damage, dmg); +} + +void +term_erase(struct terminal *term, int start, int end) +{ + assert(end >= start); + memset(&term->grid.cells[start], 0, (end - start) * sizeof(term->grid.cells[0])); + term_damage_erase(term, start, end - start); +} + +int +term_cursor_linear(const struct terminal *term, int row, int col) +{ + return row * term->grid.cols + col; +} + +void +term_cursor_to(struct terminal *term, int row, int col) +{ + assert(row >= 0); + assert(row < term->grid.rows); + assert(col >= 0); + assert(col < term->grid.cols); + + int new_linear = row * term->grid.cols + col; + assert(new_linear >= 0); + assert(new_linear < term->grid.rows * term->grid.cols); + + term_damage_update(term, term->grid.linear_cursor, 1); + term_damage_update(term, new_linear, 1); + term->grid.print_needs_wrap = false; + + term->grid.linear_cursor = new_linear; + term->grid.cursor.col = col; + term->grid.cursor.row = row; +} + +void +term_cursor_left(struct terminal *term, int count) +{ + int move_amount = min(term->grid.cursor.col, count); + term_cursor_to(term, term->grid.cursor.row, term->grid.cursor.col - move_amount); +} + +void +term_cursor_right(struct terminal *term, int count) +{ + int move_amount = min(term->grid.cols - term->grid.cursor.col - 1, count); + term_cursor_to(term, term->grid.cursor.row, term->grid.cursor.col + move_amount); +} + +void +term_cursor_up(struct terminal *term, int count) +{ + int move_amount = min(term->grid.cursor.row, count); + term_cursor_to(term, term->grid.cursor.row - move_amount, term->grid.cursor.col); +} + +void +term_cursor_down(struct terminal *term, int count) +{ + int move_amount = min(term->grid.rows - term->grid.cursor.row - 1, count); + term_cursor_to(term, term->grid.cursor.row + move_amount, term->grid.cursor.col); +} + +void +term_scroll_partial(struct terminal *term, struct scroll_region region, int rows) +{ + if (rows >= region.end - region.start) { + assert(false && "untested"); + return; + } + + int cell_dst = (region.start + 0) * term->grid.cols; + int cell_src = (region.start + rows) * term->grid.cols; + int cell_count = (region.end - region.start - rows) * term->grid.cols; + + LOG_DBG("moving %d lines from row %d to row %d", cell_count / term->grid.cols, + cell_src / term->grid.cols, cell_dst / term->grid.cols); + + const size_t bytes = cell_count * sizeof(term->grid.cells[0]); + memmove( + &term->grid.cells[cell_dst], &term->grid.cells[cell_src], + bytes); + + memset(&term->grid.cells[(region.end - rows) * term->grid.cols], 0, + rows * term->grid.cols * sizeof(term->grid.cells[0])); + + term_damage_scroll(term, DAMAGE_SCROLL, region, rows); +} + +void +term_scroll(struct terminal *term, int rows) +{ + term_scroll_partial(term, term->grid.scroll_region, rows); +} + +void +term_scroll_reverse_partial(struct terminal *term, + struct scroll_region region, int rows) +{ + if (rows >= region.end - region.start) { + assert(false && "todo"); + return; + } + + int cell_dst = (region.start + rows) * term->grid.cols; + int cell_src = (region.start + 0) * term->grid.cols; + int cell_count = (region.end - region.start - rows) * term->grid.cols; + + LOG_DBG("moving %d lines from row %d to row %d", cell_count / term->grid.cols, + cell_src / term->grid.cols, cell_dst / term->grid.cols); + + const size_t bytes = cell_count * sizeof(term->grid.cells[0]); + memmove( + &term->grid.cells[cell_dst], &term->grid.cells[cell_src], + bytes); + + memset(&term->grid.cells[cell_src], 0, + rows * term->grid.cols * sizeof(term->grid.cells[0])); + + term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows); +} + +void +term_scroll_reverse(struct terminal *term, int rows) +{ + term_scroll_reverse_partial(term, term->grid.scroll_region, rows); +} |
