From d70956da08c987af639fd8e03e669ca59c4c542b Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 1 Jul 2019 12:23:38 +0200 Subject: wip: use a sliding window instead of memmove() to scroll Instead of memmoving a large amount of data on every scroll, use a sliding window. That is, each time we scroll, we offset origin. --- terminal.c | 120 +++++++++++++++++++++---------------------------------------- 1 file changed, 41 insertions(+), 79 deletions(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index 482452c5..0bd38915 100644 --- a/terminal.c +++ b/terminal.c @@ -6,6 +6,7 @@ #define LOG_MODULE "terminal" #define LOG_ENABLE_DBG 1 #include "log.h" +#include "grid.h" #define min(x, y) ((x) < (y) ? (x) : (y)) #define max(x, y) ((x) > (y) ? (x) : (y)) @@ -37,10 +38,6 @@ damage_merge_range(struct terminal *term, const struct damage *dmg) old->range.start = new_start; old->range.length = new_end - new_start; - assert(old->range.start >= 0); - assert(old->range.start < term->rows * term->cols); - assert(old->range.length >= 0); - assert(old->range.start + old->range.length <= term->rows * term->cols); return true; } @@ -53,14 +50,8 @@ term_damage_update_or_erase(struct terminal *term, enum damage_type damage_type, { struct damage dmg = { .type = damage_type, - .range = {.start = start, .length = length}, + .range = {.start = term->grid->offset + start, .length = length}, }; - - assert(dmg.range.start >= 0); - assert(dmg.range.start < term->rows * term->cols); - assert(dmg.range.length >= 0); - assert(dmg.range.start + dmg.range.length <= term->rows * term->cols); - if (damage_merge_range(term, &dmg)) return; @@ -70,12 +61,14 @@ term_damage_update_or_erase(struct terminal *term, enum damage_type damage_type, void term_damage_update(struct terminal *term, int start, int length) { + assert(start + length <= term->rows * term->cols); term_damage_update_or_erase(term, DAMAGE_UPDATE, start, length); } void term_damage_erase(struct terminal *term, int start, int length) { + assert(start + length <= term->rows * term->cols); term_damage_update_or_erase(term, DAMAGE_ERASE, start, length); } @@ -87,82 +80,30 @@ term_damage_all(struct terminal *term) term_damage_update(term, 0, term->rows * term->cols); } +#if 0 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->cols * (damage_type == DAMAGE_SCROLL_REVERSE ? -1 : 1); - - const int scroll_start = region.start * term->cols; - const int scroll_end = region.end * term->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; - } + if (it->item.range.start < term->grid->offset) { + int end = it->item.range.start + it->item.range.length; + if (end >= term->grid->offset) { + it->item.range.start = term->grid->offset; + it->item.range.length = end - it->item.range.start; + } else { + tll_remove(term->grid->damage, it); } } } } +#endif 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); + //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); @@ -185,8 +126,11 @@ term_damage_scroll(struct terminal *term, enum damage_type damage_type, void term_erase(struct terminal *term, int start, int end) { + LOG_DBG("erase: %d-%d", start, end); assert(end >= start); - memset(&term->grid->cells[start], 0, (end - start) * sizeof(term->grid->cells[0])); + assert(end <= term->rows * term->cols); + + grid_memset(term->grid, start, 0, end - start); term_damage_erase(term, start, end - start); } @@ -199,13 +143,10 @@ term_cursor_linear(const struct terminal *term, int row, int col) void term_cursor_to(struct terminal *term, int row, int col) { - assert(row >= 0); assert(row < term->rows); - assert(col >= 0); assert(col < term->cols); int new_linear = row * term->cols + col; - assert(new_linear >= 0); assert(new_linear < term->rows * term->cols); term_damage_update(term, term->cursor.linear, 1); @@ -248,11 +189,13 @@ term_cursor_down(struct terminal *term, int count) void term_scroll_partial(struct terminal *term, struct scroll_region region, int rows) { + LOG_DBG("scroll: %d rows", rows); if (rows >= region.end - region.start) { assert(false && "untested"); return; } +#if 0 int cell_dst = (region.start + 0) * term->cols; int cell_src = (region.start + rows) * term->cols; int cell_count = (region.end - region.start - rows) * term->cols; @@ -260,7 +203,7 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows LOG_DBG("moving %d lines from row %d to row %d", cell_count / term->cols, cell_src / term->cols, cell_dst / term->cols); - const size_t bytes = cell_count * sizeof(term->grid->cells[0]); + const int bytes = cell_count * sizeof(term->grid->cells[0]); memmove( &term->grid->cells[cell_dst], &term->grid->cells[cell_src], bytes); @@ -269,6 +212,15 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows rows * term->cols * sizeof(term->grid->cells[0])); term_damage_scroll(term, DAMAGE_SCROLL, region, rows); +#else + /* TODO */ + assert(region.start == 0 && region.end == term->rows); + assert(rows < term->rows); + + term->grid->offset += rows * term->cols; + grid_memset(term->grid, (region.end - rows) * term->cols, 0, rows * term->cols); + term_damage_scroll(term, DAMAGE_SCROLL, region, rows); +#endif } void @@ -286,6 +238,7 @@ term_scroll_reverse_partial(struct terminal *term, return; } +#if 0 int cell_dst = (region.start + rows) * term->cols; int cell_src = (region.start + 0) * term->cols; int cell_count = (region.end - region.start - rows) * term->cols; @@ -293,7 +246,7 @@ term_scroll_reverse_partial(struct terminal *term, LOG_DBG("moving %d lines from row %d to row %d", cell_count / term->cols, cell_src / term->cols, cell_dst / term->cols); - const size_t bytes = cell_count * sizeof(term->grid->cells[0]); + const int bytes = cell_count * sizeof(term->grid->cells[0]); memmove( &term->grid->cells[cell_dst], &term->grid->cells[cell_src], bytes); @@ -302,6 +255,15 @@ term_scroll_reverse_partial(struct terminal *term, rows * term->cols * sizeof(term->grid->cells[0])); term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows); +#else + /* TODO */ + assert(false); + assert(region.start == 0 && region.end == 0); + assert(rows < term->rows); + + term->grid->offset -= rows * term->cols; + term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows); +#endif } void -- cgit v1.3 From 24395cf4cd2bd058ad194a8ba08c25d4b9c4d2a7 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 1 Jul 2019 19:20:21 +0200 Subject: scrolling: implement partial scrolling --- terminal.c | 68 +++++++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 45 insertions(+), 23 deletions(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index 0bd38915..c6129953 100644 --- a/terminal.c +++ b/terminal.c @@ -86,6 +86,7 @@ damage_adjust_after_scroll(struct terminal *term, enum damage_type damage_type, struct scroll_region region, int lines) { tll_foreach(term->grid->damage, it) { +#if 0 if (it->item.range.start < term->grid->offset) { int end = it->item.range.start + it->item.range.length; if (end >= term->grid->offset) { @@ -95,6 +96,12 @@ damage_adjust_after_scroll(struct terminal *term, enum damage_type damage_type, tll_remove(term->grid->damage, it); } } +#endif + + int start = it->item.range.start; + int end = start + it->item.range.length; + + if (start - } } #endif @@ -190,37 +197,52 @@ void term_scroll_partial(struct terminal *term, struct scroll_region region, int rows) { LOG_DBG("scroll: %d rows", rows); - if (rows >= region.end - region.start) { - assert(false && "untested"); - return; - } -#if 0 - int cell_dst = (region.start + 0) * term->cols; - int cell_src = (region.start + rows) * term->cols; - int cell_count = (region.end - region.start - rows) * term->cols; + if (region.start > 0) { + /* TODO: check if it's worth memoving the scroll area instead, + * under certain circumstances */ - LOG_DBG("moving %d lines from row %d to row %d", cell_count / term->cols, - cell_src / term->cols, cell_dst / term->cols); + grid_memmove(term->grid, rows * term->cols, 0, region.start * term->cols); - const int bytes = cell_count * sizeof(term->grid->cells[0]); - memmove( - &term->grid->cells[cell_dst], &term->grid->cells[cell_src], - bytes); + tll_foreach(term->grid->damage, it) { + int start = it->item.range.start - term->grid->offset; + int end = start + it->item.range.length; - memset(&term->grid->cells[(region.end - rows) * term->cols], 0, - rows * term->cols * sizeof(term->grid->cells[0])); + if (start < region.start) { + assert(end <= region.start); + it->item.range.start += rows * term->cols; + } + } + } - term_damage_scroll(term, DAMAGE_SCROLL, region, rows); -#else - /* TODO */ - assert(region.start == 0 && region.end == term->rows); - assert(rows < term->rows); + if (region.end < term->rows) { + /* Copy scrolled-up bottom region to new bottom region */ + grid_memmove( + term->grid, + (region.end + rows) * term->cols, + region.end * term->cols, + (term->rows - region.end) * term->cols); + + tll_foreach(term->grid->damage, it) { + int start = it->item.range.start - term->grid->offset; + int end = start + it->item.range.length; + + if (end > region.end) { + assert(start >= region.end); + it->item.range.start += rows * term->cols; + } + } + } + /* Offset grid origin */ term->grid->offset += rows * term->cols; - grid_memset(term->grid, (region.end - rows) * term->cols, 0, rows * term->cols); + + /* Clear scrolled-in lines */ + grid_memset( + term->grid, + max(0, region.end - rows) * term->cols, 0, rows * term->cols); + term_damage_scroll(term, DAMAGE_SCROLL, region, rows); -#endif } void -- cgit v1.3 From dfc9554e89fa741884b2140f0f1c9c2b74da0220 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 1 Jul 2019 21:13:24 +0200 Subject: render: always render cursor --- main.c | 44 +++++++++++++++++++++++++++----------------- terminal.c | 2 -- 2 files changed, 27 insertions(+), 19 deletions(-) (limited to 'terminal.c') diff --git a/main.c b/main.c index f81771ab..5c2876e6 100644 --- a/main.c +++ b/main.c @@ -260,20 +260,6 @@ grid_render_erase(struct context *c, struct buffer *buf, const struct damage *dm cairo_fill(buf->cairo); wl_surface_damage_buffer(c->wl.surface, x, y, width, height); } - - /* Redraw cursor, if it's inside the erased range */ - if (c->term.cursor.linear >= dmg->range.start - c->term.grid->offset && - c->term.cursor.linear < dmg->range.start - c->term.grid->offset + dmg->range.length) - { - grid_render_update( - c, buf, - &(struct damage){ - .type = DAMAGE_UPDATE, - .range = { - .start = c->term.grid->offset + c->term.cursor.linear, - .length = 1} - }); - } } static void @@ -362,18 +348,19 @@ grid_render_scroll_reverse(struct context *c, struct buffer *buf, static void grid_render(struct context *c) { + struct buffer *buf = shm_get_buffer(c->wl.shm, c->width, c->height); + cairo_set_operator(buf->cairo, CAIRO_OPERATOR_SOURCE); + if (tll_length(c->term.grid->damage) == 0 && tll_length(c->term.grid->scroll_damage) == 0) { - return; + goto render_cursor; } assert(c->width > 0); assert(c->height > 0); - struct buffer *buf = shm_get_buffer(c->wl.shm, c->width, c->height); - cairo_set_operator(buf->cairo, CAIRO_OPERATOR_SOURCE); tll_foreach(c->term.grid->scroll_damage, it) { switch (it->item.type) { @@ -408,6 +395,29 @@ grid_render(struct context *c) tll_remove(c->term.grid->damage, it); } +render_cursor: + ; + + /* TODO: break out to function */ + /* Re-render last cursor cell and current cursor cell */ + static struct cursor last_cursor = {.linear = 0, .col = 0, .row = 0}; + + if (last_cursor.linear != c->term.cursor.linear) { + struct damage prev_cursor = { + .type = DAMAGE_UPDATE, + .range = {.start = c->term.grid->offset + last_cursor.linear, + .length = 1}, + }; + grid_render_update(c, buf, &prev_cursor); + } + + struct damage cursor = { + .type = DAMAGE_UPDATE, + .range = {.start = c->term.grid->offset + c->term.cursor.linear, .length = 1}, + }; + grid_render_update(c, buf, &cursor); + last_cursor = c->term.cursor; + c->term.grid->offset %= c->term.grid->size; //cairo_surface_flush(buf->cairo_surface); diff --git a/terminal.c b/terminal.c index c6129953..952476f3 100644 --- a/terminal.c +++ b/terminal.c @@ -156,8 +156,6 @@ term_cursor_to(struct terminal *term, int row, int col) int new_linear = row * term->cols + col; assert(new_linear < term->rows * term->cols); - term_damage_update(term, term->cursor.linear, 1); - term_damage_update(term, new_linear, 1); term->print_needs_wrap = false; term->cursor.linear = new_linear; -- cgit v1.3 From 4b824d824c44c0694f4c3b8dd3ff039038ae76fd Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Mon, 1 Jul 2019 21:14:31 +0200 Subject: term: 'end' variable is only used in assert() --- terminal.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index 952476f3..ee46fea3 100644 --- a/terminal.c +++ b/terminal.c @@ -204,7 +204,7 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows tll_foreach(term->grid->damage, it) { int start = it->item.range.start - term->grid->offset; - int end = start + it->item.range.length; + int end __attribute__((unused)) = start + it->item.range.length; if (start < region.start) { assert(end <= region.start); -- cgit v1.3 From e17d297dca2ec2402f904a495cd5dd3d5bace032 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 2 Jul 2019 19:45:17 +0200 Subject: term: if the damage list gets too long, replace with a full redraw --- terminal.c | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index ee46fea3..2aac7f6e 100644 --- a/terminal.c +++ b/terminal.c @@ -48,10 +48,18 @@ static void term_damage_update_or_erase(struct terminal *term, enum damage_type damage_type, int start, int length) { +#if 1 + if (tll_length(term->grid->damage) > 1024) { + term_damage_all(term); + return; + } +#endif + struct damage dmg = { .type = damage_type, .range = {.start = term->grid->offset + start, .length = length}, }; + if (damage_merge_range(term, &dmg)) return; -- cgit v1.3 From dd4647e9ff792c93e596af87b9ff762e5d4580b4 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 2 Jul 2019 21:43:49 +0200 Subject: term: simplify horizontal cursor movement Since horizontal cursor movement is clamped to the current line, we can calculate the new linear cursor without any expensive multiplications and/or divisions. --- terminal.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index 2aac7f6e..f11ddad6 100644 --- a/terminal.c +++ b/terminal.c @@ -175,14 +175,18 @@ void term_cursor_left(struct terminal *term, int count) { int move_amount = min(term->cursor.col, count); - term_cursor_to(term, term->cursor.row, term->cursor.col - move_amount); + term->cursor.linear -= move_amount; + term->cursor.col -= move_amount; + term->print_needs_wrap = false; } void term_cursor_right(struct terminal *term, int count) { int move_amount = min(term->cols - term->cursor.col - 1, count); - term_cursor_to(term, term->cursor.row, term->cursor.col + move_amount); + term->cursor.linear += move_amount; + term->cursor.col += move_amount; + term->print_needs_wrap = false; } void -- cgit v1.3 From 9682e15deb2037b4da2b9796be81bd3f80e1a153 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 2 Jul 2019 22:18:25 +0200 Subject: term: "cache" pointer to current line This adds a pointer to the first cell on the current line. This pointer must be updated every time the row changes. The advantage is mainly that PRINT doesn't have to call grid_get_range(), which is fairly expensive. --- terminal.c | 12 ++++++++++++ terminal.h | 1 + vt.c | 6 +----- 3 files changed, 14 insertions(+), 5 deletions(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index f11ddad6..25e1246e 100644 --- a/terminal.c +++ b/terminal.c @@ -169,6 +169,12 @@ term_cursor_to(struct terminal *term, int row, int col) term->cursor.linear = new_linear; term->cursor.col = col; term->cursor.row = row; + + size_t len = term->cols; + term->grid->cur_line = grid_get_range( + term->grid, term->cursor.linear - col, &len); + + assert(len == (size_t)term->cols); } void @@ -253,6 +259,12 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows max(0, region.end - rows) * term->cols, 0, rows * term->cols); term_damage_scroll(term, DAMAGE_SCROLL, region, rows); + + size_t len = term->cols; + term->grid->cur_line = grid_get_range( + term->grid, term->cursor.linear - term->cursor.col, &len); + + assert(len == (size_t)term->cols); } void diff --git a/terminal.h b/terminal.h index 4efaab9f..66f6bde0 100644 --- a/terminal.h +++ b/terminal.h @@ -66,6 +66,7 @@ struct grid { int offset; struct cell *cells; + struct cell *cur_line; tll(struct damage) damage; tll(struct damage) scroll_damage; diff --git a/vt.c b/vt.c index 5d04008b..f2d85d4b 100644 --- a/vt.c +++ b/vt.c @@ -678,11 +678,7 @@ action(struct terminal *term, enum action action, uint8_t c) term_cursor_to(term, term->cursor.row + 1, 0); } - size_t cell_count = 1; - struct cell *cell = grid_get_range( - term->grid, term->cursor.linear, &cell_count); - assert(cell_count == 1); - + struct cell *cell = &term->grid->cur_line[term->cursor.col]; term_damage_update(term, term->cursor.linear, 1); if (term->vt.utf8.idx > 0) { -- cgit v1.3 From e6c27645fab5b5c6319b180ae6052cd507c6ab4f Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 3 Jul 2019 09:23:42 +0200 Subject: term: optimize damage list after scroll This optimizes the normal scrolling case; updates are done at the bottom of the screen and then scrolled up. In this case, the damage list will be a more or less sorted list of updates, oldest first. If we're scrolling a lot, the oldest updates will eventually scroll off screen. In this case, there's no need to keep them in the damage list. So, when scrolling, loop the damage list and adjust/remove updates that have scrolled off screen (either partially, or completely). Stop looping as soon as we see an update that has *not* scrolled off screen. Note that this means there may be update items in the damage list that *has* scrolled off screen. This is especially true for random screen writes (i.e. typical to some synthetic benchmarks). --- terminal.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index 25e1246e..2c96e3cf 100644 --- a/terminal.c +++ b/terminal.c @@ -119,6 +119,23 @@ 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 (damage_type == DAMAGE_SCROLL) { + tll_foreach(term->grid->damage, it) { + int start = it->item.range.start; + int length = it->item.range.length; + + if (start < term->grid->offset) { + int end = start + length; + if (end >= term->grid->offset) { + it->item.range.start = term->grid->offset; + it->item.range.length = end - it->item.range.start; + } else + tll_remove(term->grid->damage, it); + } else + break; + } + } else + assert(false); if (tll_length(term->grid->scroll_damage) > 0) { struct damage *dmg = &tll_back(term->grid->scroll_damage); -- cgit v1.3 From a7a28ff5816c0f80a439c4ad828c6f0028493b1f Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 3 Jul 2019 10:45:49 +0200 Subject: scrolling: initial reverse scrolling support - no scroll regions --- grid.c | 23 +++++++++++++---------- grid.h | 6 +++--- main.c | 19 +++++++++++++++---- terminal.c | 46 ++++++++++++++-------------------------------- 4 files changed, 45 insertions(+), 49 deletions(-) (limited to 'terminal.c') diff --git a/grid.c b/grid.c index a21e0c88..99e66665 100644 --- a/grid.c +++ b/grid.c @@ -8,12 +8,15 @@ #include "log.h" struct cell * -grid_get_range(struct grid *grid, size_t start, size_t *length) +grid_get_range(struct grid *grid, int start, int *length) { #define min(x, y) ((x) < (y) ? (x) : (y)) assert(*length <= grid->size); - size_t real_start = (grid->offset + start) % grid->size; + int real_start = (grid->offset + start) % grid->size; + if (real_start < 0) + real_start += grid->size; + assert(real_start >= 0); assert(real_start < grid->size); *length = min(*length, grid->size - real_start); @@ -24,11 +27,11 @@ grid_get_range(struct grid *grid, size_t start, size_t *length) } void -grid_memset(struct grid *grid, size_t start, int c, size_t length) +grid_memset(struct grid *grid, int start, int c, int length) { - size_t left = length; + int left = length; while (left > 0) { - size_t count = left; + int count = left; struct cell *cells = grid_get_range(grid, start, &count); assert(count > 0); @@ -42,14 +45,14 @@ grid_memset(struct grid *grid, size_t start, int c, size_t length) } void -grid_memmove(struct grid *grid, size_t dst, size_t src, size_t length) +grid_memmove(struct grid *grid, int dst, int src, int length) { - size_t left = length; - size_t copy_idx = 0; + int left = length; + int copy_idx = 0; struct cell copy[left]; while (left > 0) { - size_t count = left; + int count = left; struct cell *src_cells = grid_get_range(grid, src, &count); memcpy(©[copy_idx], src_cells, count * sizeof(copy[0])); @@ -63,7 +66,7 @@ grid_memmove(struct grid *grid, size_t dst, size_t src, size_t length) copy_idx = 0; while (left > 0) { - size_t count = left; + int count = left; struct cell *dst_cells = grid_get_range(grid, dst, &count); memcpy(dst_cells, ©[copy_idx], count * sizeof(copy[0])); diff --git a/grid.h b/grid.h index 275d81bc..59d9e58b 100644 --- a/grid.h +++ b/grid.h @@ -3,6 +3,6 @@ #include #include "terminal.h" -struct cell *grid_get_range(struct grid *grid, size_t start, size_t *length); -void grid_memset(struct grid *grid, size_t start, int c, size_t length); -void grid_memmove(struct grid *grid, size_t dst, size_t src, size_t length); +struct cell *grid_get_range(struct grid *grid, int start, int *length); +void grid_memset(struct grid *grid, int start, int c, int length); +void grid_memmove(struct grid *grid, int dst, int src, int length); diff --git a/main.c b/main.c index e3612d2e..460f36e4 100644 --- a/main.c +++ b/main.c @@ -118,10 +118,19 @@ grid_render_update(struct context *c, struct buffer *buf, const struct damage *d row += col == 0 ? 1 : 0) { - //LOG_DBG("UPDATE: %d (%dx%d)", linear_cursor, row, col); + assert(row >= 0); + assert(row < c->term.rows); + assert(col >= 0); + assert(col < c->term.cols); - const struct cell *cell - = &c->term.grid->cells[linear_cursor % c->term.grid->size]; + int cell_idx = linear_cursor % c->term.grid->size; + if (cell_idx < 0) + cell_idx += c->term.grid->size; + + assert(cell_idx >= 0); + assert(cell_idx < c->term.rows * c->term.cols); + + const struct cell *cell = &c->term.grid->cells[cell_idx]; /* Cursor here? */ bool has_cursor @@ -376,7 +385,7 @@ grid_render_scroll_reverse(struct context *c, struct buffer *buf, struct damage erase = { .type = DAMAGE_ERASE, .range = { - .start = dmg->scroll.region.start * cols, + .start = c->term.grid->offset + dmg->scroll.region.start * cols, .length = min(dmg->scroll.region.end - dmg->scroll.region.start, dmg->scroll.lines) * cols, }, @@ -461,6 +470,8 @@ grid_render(struct context *c) last_cursor = c->term.grid->offset + c->term.cursor.linear; c->term.grid->offset %= c->term.grid->size; + if (c->term.grid->offset < 0) + c->term.grid->offset += c->term.grid->size; //cairo_surface_flush(buf->cairo_surface); wl_surface_attach(c->wl.surface, buf->wl_buf, 0, 0); diff --git a/terminal.c b/terminal.c index 2c96e3cf..d7eeba15 100644 --- a/terminal.c +++ b/terminal.c @@ -134,8 +134,7 @@ term_damage_scroll(struct terminal *term, enum damage_type damage_type, } else break; } - } else - assert(false); + } if (tll_length(term->grid->scroll_damage) > 0) { struct damage *dmg = &tll_back(term->grid->scroll_damage); @@ -187,11 +186,11 @@ term_cursor_to(struct terminal *term, int row, int col) term->cursor.col = col; term->cursor.row = row; - size_t len = term->cols; + int len = term->cols; term->grid->cur_line = grid_get_range( term->grid, term->cursor.linear - col, &len); - assert(len == (size_t)term->cols); + assert(len == term->cols); } void @@ -277,11 +276,11 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows term_damage_scroll(term, DAMAGE_SCROLL, region, rows); - size_t len = term->cols; + int len = term->cols; term->grid->cur_line = grid_get_range( term->grid, term->cursor.linear - term->cursor.col, &len); - assert(len == (size_t)term->cols); + assert(len == term->cols); } void @@ -294,37 +293,20 @@ void term_scroll_reverse_partial(struct terminal *term, struct scroll_region region, int rows) { - if (rows >= region.end - region.start) { - assert(false && "todo"); - return; - } + assert(region.start == 0); + assert(region.end == term->rows); -#if 0 - int cell_dst = (region.start + rows) * term->cols; - int cell_src = (region.start + 0) * term->cols; - int cell_count = (region.end - region.start - rows) * term->cols; - - LOG_DBG("moving %d lines from row %d to row %d", cell_count / term->cols, - cell_src / term->cols, cell_dst / term->cols); - - const int bytes = cell_count * sizeof(term->grid->cells[0]); - memmove( - &term->grid->cells[cell_dst], &term->grid->cells[cell_src], - bytes); + term->grid->offset -= rows * term->cols; - memset(&term->grid->cells[cell_src], 0, - rows * term->cols * sizeof(term->grid->cells[0])); + grid_memset(term->grid, region.start * term->cols, 0, rows * term->cols); term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows); -#else - /* TODO */ - assert(false); - assert(region.start == 0 && region.end == 0); - assert(rows < term->rows); - term->grid->offset -= rows * term->cols; - term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows); -#endif + int len = term->cols; + term->grid->cur_line = grid_get_range( + term->grid, term->cursor.linear - term->cursor.col, &len); + + assert(len == term->cols); } void -- cgit v1.3 From 70743fddf4bd390e684f56d2c974e0b9c3507a1e Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 3 Jul 2019 14:15:23 +0200 Subject: scrolling: hopefully fix bad damage update of items outside scrolling region --- terminal.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index d7eeba15..df74e9db 100644 --- a/terminal.c +++ b/terminal.c @@ -240,8 +240,8 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows int start = it->item.range.start - term->grid->offset; int end __attribute__((unused)) = start + it->item.range.length; - if (start < region.start) { - assert(end <= region.start); + if (start < region.start * term->cols) { + assert(end <= region.start * term->cols); it->item.range.start += rows * term->cols; } } @@ -259,8 +259,8 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows int start = it->item.range.start - term->grid->offset; int end = start + it->item.range.length; - if (end > region.end) { - assert(start >= region.end); + if (end > region.end * term->cols) { + assert(start >= region.end * term->cols); it->item.range.start += rows * term->cols; } } -- cgit v1.3 From 1f343527f065352f34af06d8d6a7cbd3e6c82cb5 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 3 Jul 2019 14:15:46 +0200 Subject: scrolling: make sure we don't clear too much memory --- terminal.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index df74e9db..49c8e390 100644 --- a/terminal.c +++ b/terminal.c @@ -272,7 +272,9 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows /* Clear scrolled-in lines */ grid_memset( term->grid, - max(0, region.end - rows) * term->cols, 0, rows * term->cols); + max(0, region.end - rows) * term->cols, + 0, + min(rows, term->rows) * term->cols); term_damage_scroll(term, DAMAGE_SCROLL, region, rows); -- cgit v1.3 From da305abdd8b6a76156877e4cf1104767d77d6b56 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 3 Jul 2019 14:16:01 +0200 Subject: scrolling: initial implementation of scrolling region when reverse scrolling --- terminal.c | 40 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 38 insertions(+), 2 deletions(-) (limited to 'terminal.c') diff --git a/terminal.c b/terminal.c index 49c8e390..7ba0aa13 100644 --- a/terminal.c +++ b/terminal.c @@ -295,8 +295,44 @@ void term_scroll_reverse_partial(struct terminal *term, struct scroll_region region, int rows) { - assert(region.start == 0); - assert(region.end == term->rows); + if (region.end < term->rows) { + grid_memmove( + term->grid, + (region.end - rows) * term->cols, + region.end * term->cols, + (term->rows - region.end) * term->cols); + + tll_foreach(term->grid->damage, it) { + int start = it->item.range.start - term->grid->offset; + int end = start + it->item.range.length; + + if (end > region.end * term->cols) { + assert(start >= region.end * term->cols); + it->item.range.start -= rows * term->cols; + } + } + + } + + if (region.start > 0) { + grid_memmove( + term->grid, -rows * term->cols, 0, region.start * term->cols); + + tll_foreach(term->grid->damage, it) { + int start = it->item.range.start - term->grid->offset; + int end __attribute__((unused)) = start + it->item.range.length; + + if (start < region.start * term->cols) { + if (end > region.start * term->cols) { + LOG_ERR("region.start = %d, rows = %d, damage.start = %d, damage.end = %d (%s)", + region.start, rows, start, end, it->item.type == DAMAGE_UPDATE ? "UPDATE" : "ERASE"); + abort(); + } + assert(end <= region.start * term->cols); + it->item.range.start -= rows * term->cols; + } + } + } term->grid->offset -= rows * term->cols; -- cgit v1.3 From 1373d18dbc7b04141347a20a58867c1c79cf6daf Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Wed, 3 Jul 2019 20:21:03 +0200 Subject: logging: disable debug logging by default --- csi.c | 2 +- grid.c | 2 +- input.c | 2 +- main.c | 2 +- osc.c | 2 +- slave.c | 2 +- terminal.c | 2 +- vt.c | 2 +- 8 files changed, 8 insertions(+), 8 deletions(-) (limited to 'terminal.c') diff --git a/csi.c b/csi.c index 530a494c..4be35c60 100644 --- a/csi.c +++ b/csi.c @@ -10,7 +10,7 @@ #endif #define LOG_MODULE "csi" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" #include "grid.h" diff --git a/grid.c b/grid.c index 99e66665..178883e4 100644 --- a/grid.c +++ b/grid.c @@ -4,7 +4,7 @@ #include #define LOG_MODULE "grid" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" struct cell * diff --git a/input.c b/input.c index 5e61d49b..319de914 100644 --- a/input.c +++ b/input.c @@ -10,7 +10,7 @@ #include #define LOG_MODULE "input" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" #include "terminal.h" diff --git a/main.c b/main.c index 133880ee..b69f42de 100644 --- a/main.c +++ b/main.c @@ -17,7 +17,7 @@ #include #define LOG_MODULE "main" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" #include "font.h" diff --git a/osc.c b/osc.c index 5f71287e..2882d546 100644 --- a/osc.c +++ b/osc.c @@ -1,7 +1,7 @@ #include "osc.h" #define LOG_MODULE "osc" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" bool diff --git a/slave.c b/slave.c index edb5e9c6..676d4ce2 100644 --- a/slave.c +++ b/slave.c @@ -9,7 +9,7 @@ #include #define LOG_MODULE "slave" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" void diff --git a/terminal.c b/terminal.c index 7ba0aa13..4de5a1a8 100644 --- a/terminal.c +++ b/terminal.c @@ -4,7 +4,7 @@ #include #define LOG_MODULE "terminal" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" #include "grid.h" diff --git a/vt.c b/vt.c index b2cc07fa..c5786b2f 100644 --- a/vt.c +++ b/vt.c @@ -5,7 +5,7 @@ #include #define LOG_MODULE "vt" -#define LOG_ENABLE_DBG 1 +#define LOG_ENABLE_DBG 0 #include "log.h" #include "csi.h" #include "osc.h" -- cgit v1.3