aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDaniel Eklöf <daniel@ekloef.se>2019-06-25 18:11:08 +0000
committerDaniel Eklöf <daniel@ekloef.se>2019-06-25 18:11:08 +0000
commita35738d96f251379074a8e79ec2c179afcfe79fa (patch)
tree53c2bf94426f7c402a022afa9d031fdd762ce747
parentgrid: scroll reverse: hopefully done correct now (diff)
scroll-region: don't clear damage queue when changing scroll region
Vim, for example, changes the scroll region every time you scroll a single line. Thus, resetting the damage queue is slow. This reworks the damage handling of scroll updates: * Split damage queue into two: one for scroll operations and one for update/erase operations. * Don't separate update/erase operations inside/outside the scroll region * Store the current scroll region in the scroll damage operation. This allows us to stack multiple scroll operations with different scroll regions. * When updating update/erase operations after a scroll operation, split the update/erase operations if necessary (the current scroll operation may have a scroll region different from before, thus forcing us to split existing update/erase operations. * The renderer no longer erases after a scroll. The scroll operation also adds an erase operation. This also means that erase operation are subject to adjustments by later scroll operations.
-rw-r--r--csi.c49
-rw-r--r--grid.c215
-rw-r--r--grid.h10
-rw-r--r--main.c79
-rw-r--r--terminal.h19
-rw-r--r--vt.c4
6 files changed, 168 insertions, 208 deletions
diff --git a/csi.c b/csi.c
index 9cbbbd45..49431bca 100644
--- a/csi.c
+++ b/csi.c
@@ -386,37 +386,37 @@ csi_dispatch(struct terminal *term, uint8_t final)
}
case 'L': {
- if (term->grid.cursor.row < term->grid.scrolling_region.start ||
- term->grid.cursor.row >= term->grid.scrolling_region.end)
+ if (term->grid.cursor.row < term->grid.scroll_region.start ||
+ term->grid.cursor.row >= term->grid.scroll_region.end)
break;
int count = min(
param_get(term, 0, 1),
- term->grid.scrolling_region.end - term->grid.cursor.row);
-
- LOG_DBG("reverse partial: %d, %d rows",
- term->grid.cursor.row - term->grid.scrolling_region.start,
- count);
+ term->grid.scroll_region.end - term->grid.cursor.row);
grid_scroll_reverse_partial(
&term->grid,
- term->grid.cursor.row - term->grid.scrolling_region.start,
+ (struct scroll_region){
+ .start = term->grid.cursor.row,
+ .end = term->grid.scroll_region.end},
count);
break;
}
case 'M': {
- if (term->grid.cursor.row < term->grid.scrolling_region.start ||
- term->grid.cursor.row >= term->grid.scrolling_region.end)
+ if (term->grid.cursor.row < term->grid.scroll_region.start ||
+ term->grid.cursor.row >= term->grid.scroll_region.end)
break;
int count = min(
param_get(term, 0, 1),
- term->grid.scrolling_region.end - term->grid.cursor.row);
+ term->grid.scroll_region.end - term->grid.cursor.row);
grid_scroll_partial(
&term->grid,
- term->grid.cursor.row - term->grid.scrolling_region.start,
+ (struct scroll_region){
+ .start = term->grid.cursor.row,
+ .end = term->grid.scroll_region.end},
count);
break;
}
@@ -449,16 +449,12 @@ csi_dispatch(struct terminal *term, uint8_t final)
int end = param_get(term, 1, term->grid.rows);
/* 1-based */
- term->grid.scrolling_region.start = start - 1;
- term->grid.scrolling_region.end = end;
-
- LOG_INFO("scrolling region: %d-%d",
- term->grid.scrolling_region.start,
- term->grid.scrolling_region.end);
+ term->grid.scroll_region.start = start - 1;
+ term->grid.scroll_region.end = end;
- tll_free(term->grid.damage);
- grid_damage_update(&term->grid, 0, term->grid.rows * term->grid.cols);
- grid_cursor_to(&term->grid, 0, 0);
+ LOG_INFO("scroll region: %d-%d",
+ term->grid.scroll_region.start,
+ term->grid.scroll_region.end);
break;
}
@@ -562,8 +558,7 @@ csi_dispatch(struct terminal *term, uint8_t final)
term->grid.alt_saved_cursor.row = term->grid.cursor.row;
term->grid.alt_saved_cursor.col = term->grid.cursor.col;
- tll_free(term->grid.damage);
- grid_erase(&term->grid, 0, term->grid.cols * term->grid.rows);
+ grid_damage_all(&term->grid);
}
break;
@@ -622,12 +617,10 @@ csi_dispatch(struct terminal *term, uint8_t final)
&term->grid, term->grid.cursor.row, term->grid.cursor.col);
/* Should these be restored from saved values? */
- term->grid.scrolling_region.start = 0;
- term->grid.scrolling_region.end = term->grid.rows;
+ term->grid.scroll_region.start = 0;
+ term->grid.scroll_region.end = term->grid.rows;
- tll_free(term->grid.damage);
- grid_damage_update(
- &term->grid, 0, term->grid.cols * term->grid.rows);
+ grid_damage_all(&term->grid);
}
break;
diff --git a/grid.c b/grid.c
index d4b8cbe5..f588f6e0 100644
--- a/grid.c
+++ b/grid.c
@@ -51,48 +51,6 @@ static void
grid_damage_update_or_erase(struct grid *grid, enum damage_type damage_type,
int start, int length)
{
- const int cols = grid->cols;
-
- if (length == 0)
- return;
-
- if (start < grid->scrolling_region.start * cols) {
- int len = min(length, grid->scrolling_region.start * cols);
-
- struct damage dmg = {
- .type = damage_type + 1,
- .range = {.start = start, .length = len},
- };
-
- tll_push_back(grid->damage, dmg);
- start += len;
- length -= len;
- }
-
- assert(start >= grid->scrolling_region.start * cols);
-
- if (length == 0)
- return;
-
- if (start + length > (grid->scrolling_region.end * cols)) {
- int partial_start = max(start, grid->scrolling_region.end * cols);
- int len = start + length - partial_start;
-
- struct damage dmg = {
- .type = damage_type + 1,
- .range = {.start = partial_start, .length = len},
- };
-
- tll_push_back(grid->damage, dmg);
- length -= len;
- }
-
- if (length == 0)
- return;
-
- assert(start < grid->scrolling_region.end * cols);
- assert(start + length <= grid->scrolling_region.end * cols);
-
struct damage dmg = {
.type = damage_type,
.range = {.start = start, .length = length},
@@ -121,86 +79,111 @@ grid_damage_erase(struct grid *grid, int start, int length)
grid_damage_update_or_erase(grid, DAMAGE_ERASE, start, length);
}
+void
+grid_damage_all(struct grid *grid)
+{
+ tll_free(grid->damage);
+ tll_free(grid->scroll_damage);
+ grid_damage_update(grid, 0, grid->rows * grid->cols);
+}
+
static void
damage_adjust_after_scroll(struct grid *grid, enum damage_type damage_type,
- int lines)
+ struct scroll_region region, int lines)
{
- int top_margin = grid->scrolling_region.start;
- int bottom_margin = grid->rows - grid->scrolling_region.end;
-
const int adjustment
= lines * grid->cols * (damage_type == DAMAGE_SCROLL_REVERSE ? -1 : 1);
- top_margin *= grid->cols;
- bottom_margin *= grid->cols;
+
+ const int scroll_start = region.start * grid->cols;
+ const int scroll_end = region.end * grid->cols;
tll_foreach(grid->damage, it) {
- if (!(it->item.type == DAMAGE_UPDATE || it->item.type == DAMAGE_ERASE))
- continue;
+ int start = it->item.range.start;
+ int length = it->item.range.length;
+ int end = start + length;
- assert(it->item.range.start >= grid->scrolling_region.start * grid->cols);
- assert(it->item.range.start + it->item.range.length <=
- grid->scrolling_region.end * grid->cols);
+ 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},
+ };
- it->item.range.start -= adjustment;
- int end = it->item.range.start + it->item.range.length;
+ tll_push_back(grid->damage, outside);
+ start = scroll_start;
+ length = end - start;
- if (damage_type == DAMAGE_SCROLL && it->item.range.start < top_margin) {
- /* Scrolled of screen (partially, or completely) */
- int new_length = it->item.range.length - (top_margin - it->item.range.start);
- assert(new_length < it->item.range.length);
+ }
- if (new_length <= 0)
- tll_remove(grid->damage, it);
- else {
- it->item.range.length = new_length;
- it->item.range.start = 0;
- }
+ 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(grid->damage, outside);
+ end = scroll_end;
+ length = end - start;
}
- else if (damage_type == DAMAGE_SCROLL_REVERSE &&
- end >= (grid->rows * grid->cols - bottom_margin))
- {
- /* Scrolled of screen (partially, or completely) */
- if (it->item.range.start >= (grid->rows * grid->cols - bottom_margin))
- tll_remove(grid->damage, it);
- else
- it->item.range.length =
- (grid->rows * grid->cols - bottom_margin) - it->item.range.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(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(grid->damage, it);
+ else {
+ it->item.range.start = start;
+ it->item.range.length = scroll_end - start;
+ }
+ }
}
}
}
void
grid_damage_scroll(struct grid *grid, enum damage_type damage_type,
- int offset, int lines)
+ struct scroll_region region, int lines)
{
- if (tll_length(grid->damage) > 0 &&
- tll_front(grid->damage).type == damage_type &&
- tll_front(grid->damage).scroll.offset == offset)
+ damage_adjust_after_scroll(grid, damage_type, region, lines);
+
+ if (tll_length(grid->scroll_damage) > 0 &&
+ tll_back(grid->scroll_damage).type == damage_type &&
+ tll_back(grid->scroll_damage).scroll.region.start == region.start &&
+ tll_back(grid->scroll_damage).scroll.region.end == region.end)
{
/* Merge with existing scroll damage */
- struct damage *dmg = &tll_front(grid->damage);
+ struct damage *dmg = &tll_back(grid->scroll_damage);
dmg->scroll.lines += lines;
- const int scrolling_region =
- grid->scrolling_region.end - grid->scrolling_region.start;
-
- /* If we've scrolled away the entire screen, replace with an erase */
- if (dmg->scroll.lines >= scrolling_region - offset) {
- dmg->type = DAMAGE_ERASE;
- dmg->range.start = (grid->scrolling_region.start + offset) * grid->cols;
- dmg->range.length = (scrolling_region - offset) * grid->cols;
- }
+ /* If we've scrolled away the entire screen, remove it all together */
+ if (dmg->scroll.lines >= region.end - region.start)
+ tll_pop_back(grid->scroll_damage);
} else {
struct damage dmg = {
.type = damage_type,
- .scroll = {.offset = offset, .lines = lines},
+ .scroll = {.region = region, .lines = lines},
};
- tll_push_front(grid->damage, dmg);
+ tll_push_back(grid->scroll_damage, dmg);
}
-
- damage_adjust_after_scroll(grid, damage_type, lines);
}
void
@@ -275,74 +258,68 @@ grid_cursor_down(struct grid *grid, int count)
}
void
-grid_scroll_partial(struct grid *grid, int offset, int rows)
+grid_scroll_partial(struct grid *grid, struct scroll_region region, int rows)
{
- const int grid_rows = grid->scrolling_region.end - grid->scrolling_region.start;
- const int top_margin = grid->scrolling_region.start;
- //const int bottom_margin = grid->rows - grid->scrolling_region.end;
-
- if (rows >= grid_rows - offset) {
+ if (rows >= region.end - region.start) {
assert(false && "untested");
return;
}
- int cell_dst = (top_margin + offset) * grid->cols;
- int cell_src = (top_margin + offset + rows) * grid->cols;
- int cell_count = (grid_rows - offset - rows) * grid->cols;
+ int cell_dst = (region.start + 0) * grid->cols;
+ int cell_src = (region.start + rows) * grid->cols;
+ int cell_count = (region.end - region.start - rows) * grid->cols;
LOG_DBG("moving %d lines from row %d to row %d", cell_count / grid->cols,
- cell_src / grid->cols, (top_margin + offset) / grid->cols);
+ cell_src / grid->cols, cell_dst / grid->cols);
const size_t bytes = cell_count * sizeof(grid->cells[0]);
memmove(
&grid->cells[cell_dst], &grid->cells[cell_src],
bytes);
- grid_damage_scroll(grid, DAMAGE_SCROLL, offset, rows);
+ grid_damage_scroll(grid, DAMAGE_SCROLL, region, rows);
grid_erase(
grid,
- (grid->scrolling_region.end - rows) * grid->cols,
- grid->scrolling_region.end * grid->cols);
+ (region.end - rows) * grid->cols,
+ region.end * grid->cols);
}
void
grid_scroll(struct grid *grid, int rows)
{
- grid_scroll_partial(grid, 0, rows);
+ grid_scroll_partial(grid, grid->scroll_region, rows);
}
void
-grid_scroll_reverse_partial(struct grid *grid, int offset, int rows)
+grid_scroll_reverse_partial(struct grid *grid,
+ struct scroll_region region, int rows)
{
- const int grid_rows = grid->scrolling_region.end - grid->scrolling_region.start;
- const int top_margin = grid->scrolling_region.start;
-
- if (rows >= grid_rows - offset) {
+ if (rows >= region.end - region.start) {
assert(false && "todo");
return;
}
- int cell_dst = (top_margin + offset + rows) * grid->cols;
- int cell_src = (top_margin + offset) * grid->cols;
- int cell_count = (grid_rows - offset - rows) * grid->cols;
+ int cell_dst = (region.start + rows) * grid->cols;
+ int cell_src = (region.start + 0) * grid->cols;
+ int cell_count = (region.end - region.start - rows) * grid->cols;
LOG_DBG("moving %d lines from row %d to row %d", cell_count / grid->cols,
- cell_src / grid->cols, (top_margin + offset) / grid->cols);
+ cell_src / grid->cols, cell_dst / grid->cols);
const size_t bytes = cell_count * sizeof(grid->cells[0]);
memmove(
&grid->cells[cell_dst], &grid->cells[cell_src],
bytes);
- grid_damage_scroll(grid, DAMAGE_SCROLL_REVERSE, offset, rows);
+ grid_damage_scroll(grid, DAMAGE_SCROLL_REVERSE, region, rows);
grid_erase(
grid,
- (top_margin + offset) * grid->cols,
- (top_margin + offset + rows) * grid->cols);
+ region.start * grid->cols,
+ (region.start + rows) * grid->cols);
}
void
grid_scroll_reverse(struct grid *grid, int rows)
{
- grid_scroll_reverse_partial(grid, 0, rows);
+ grid_scroll_reverse_partial(grid, grid->scroll_region, rows);
}
diff --git a/grid.h b/grid.h
index d27099cd..4854582d 100644
--- a/grid.h
+++ b/grid.h
@@ -2,10 +2,12 @@
#include "terminal.h"
+void grid_damage_all(struct grid *grid);
void grid_damage_update(struct grid *grid, int start, int length);
void grid_damage_erase(struct grid *grid, int start, int length);
void grid_damage_scroll(
- struct grid *grid, enum damage_type damage_type, int offset, int lines);
+ struct grid *grid, enum damage_type damage_type,
+ struct scroll_region region, int lines);
void grid_erase(struct grid *grid, int start, int end);
@@ -18,8 +20,10 @@ void grid_cursor_down(struct grid *grid, int count);
void grid_scroll(struct grid *grid, int rows);
void grid_scroll_reverse(struct grid *grid, int rows);
-void grid_scroll_partial(struct grid *grid, int offset, int rows);
-void grid_scroll_reverse_partial(struct grid *grid, int offset, int rows);
+void grid_scroll_partial(
+ struct grid *grid, struct scroll_region region, int rows);
+void grid_scroll_reverse_partial(
+ struct grid *grid, struct scroll_region region, int rows);
int grid_cursor_linear(const struct grid *grid, int row, int col);
diff --git a/main.c b/main.c
index c7a89fed..296414b7 100644
--- a/main.c
+++ b/main.c
@@ -255,20 +255,16 @@ static void
grid_render_scroll(struct context *c, struct buffer *buf,
const struct damage *dmg)
{
- //int x = 0;
- const int scrolling_region
- = c->term.grid.scrolling_region.end - c->term.grid.scrolling_region.start;
-
- int dst_y = (c->term.grid.scrolling_region.start + dmg->scroll.offset + 0) * c->term.grid.cell_height;
- int src_y = (c->term.grid.scrolling_region.start + dmg->scroll.offset + dmg->scroll.lines) * c->term.grid.cell_height;
+ int dst_y = (dmg->scroll.region.start + 0) * c->term.grid.cell_height;
+ int src_y = (dmg->scroll.region.start + dmg->scroll.lines) * c->term.grid.cell_height;
int width = buf->width;
- int height = (scrolling_region - dmg->scroll.offset - dmg->scroll.lines) * c->term.grid.cell_height;
+ int height = (dmg->scroll.region.end - dmg->scroll.region.start - dmg->scroll.lines) * c->term.grid.cell_height;
const uint32_t stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
LOG_DBG("damage: SCROLL: %d-%d by %d lines (dst-y: %d, src-y: %d, "
"height: %d, stride: %d, mmap-size: %zu)",
- c->term.grid.scrolling_region.start, c->term.grid.scrolling_region.end,
+ dmg->scroll.region.start, dmg->scroll.region.end,
dmg->scroll.lines,
dst_y, src_y, height, stride,
buf->size);
@@ -281,38 +277,33 @@ grid_render_scroll(struct context *c, struct buffer *buf,
wl_surface_damage_buffer(c->wl.surface, 0, dst_y, width, height);
- assert(dmg->scroll.offset == 0 && "todo");
-
+#if 0
const int cols = c->term.grid.cols;
struct damage erase = {
.type = DAMAGE_ERASE,
.range = {
- .start = (c->term.grid.scrolling_region.end -
- dmg->scroll.lines) * cols,
+ .start = (dmg->scroll.region.end - dmg->scroll.lines) * cols,
.length = dmg->scroll.lines * cols
},
};
grid_render_erase(c, buf, &erase);
+#endif
}
static void
grid_render_scroll_reverse(struct context *c, struct buffer *buf,
const struct damage *dmg)
{
- //int x = 0;
- const int scrolling_region =
- c->term.grid.scrolling_region.end - c->term.grid.scrolling_region.start;
-
- int src_y = (c->term.grid.scrolling_region.start + dmg->scroll.offset + 0) * c->term.grid.cell_height;
- int dst_y = (c->term.grid.scrolling_region.start + dmg->scroll.offset + dmg->scroll.lines) * c->term.grid.cell_height;
+ int src_y = (dmg->scroll.region.start + 0) * c->term.grid.cell_height;
+ int dst_y = (dmg->scroll.region.start + dmg->scroll.lines) * c->term.grid.cell_height;
int width = buf->width;
- int height = (scrolling_region - dmg->scroll.offset - dmg->scroll.lines) * c->term.grid.cell_height;
+ int height = (dmg->scroll.region.end - dmg->scroll.region.start - dmg->scroll.lines) * c->term.grid.cell_height;
const uint32_t stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
LOG_DBG("damage: SCROLL REVERSE: %d-%d by %d lines (dst-y: %d, src-y: %d, "
"height: %d, stride: %d, mmap-size: %zu)",
- c->term.grid.scrolling_region.start, c->term.grid.scrolling_region.end,
+ dmg->scroll.region.start, dmg->scroll.region.end,
dmg->scroll.lines,
dst_y, src_y, height, stride,
buf->size);
@@ -324,16 +315,6 @@ grid_render_scroll_reverse(struct context *c, struct buffer *buf,
cairo_surface_mark_dirty(buf->cairo_surface);
wl_surface_damage_buffer(c->wl.surface, 0, dst_y, width, height);
-
- const int cols = c->term.grid.cols;
- struct damage erase = {
- .type = DAMAGE_ERASE,
- .range = {
- .start = (c->term.grid.scrolling_region.start + dmg->scroll.offset) * cols,
- .length = dmg->scroll.lines * cols
- },
- };
- grid_render_erase(c, buf, &erase);
}
static void
@@ -349,25 +330,33 @@ grid_render(struct context *c)
cairo_set_operator(buf->cairo, CAIRO_OPERATOR_SOURCE);
- //bool scroll = false;
- tll_foreach(c->term.grid.damage, it) {
+ tll_foreach(c->term.grid.scroll_damage, it) {
switch (it->item.type) {
- case DAMAGE_ERASE:
- case DAMAGE_ERASE_NO_SCROLL:
- grid_render_erase(c, buf, &it->item);
+ case DAMAGE_SCROLL:
+ grid_render_scroll(c, buf, &it->item);
break;
- case DAMAGE_UPDATE:
- case DAMAGE_UPDATE_NO_SCROLL:
- grid_render_update(c, buf, &it->item);
+ case DAMAGE_SCROLL_REVERSE:
+ grid_render_scroll_reverse(c, buf, &it->item);
break;
- case DAMAGE_SCROLL:
- grid_render_scroll(c, buf, &it->item);
+ case DAMAGE_UPDATE:
+ case DAMAGE_ERASE:
+ assert(false);
break;
+ }
+
+ tll_remove(c->term.grid.scroll_damage, it);
+ }
+
+ tll_foreach(c->term.grid.damage, it) {
+ switch (it->item.type) {
+ case DAMAGE_ERASE: grid_render_erase(c, buf, &it->item); break;
+ case DAMAGE_UPDATE: grid_render_update(c, buf, &it->item); break;
+ case DAMAGE_SCROLL:
case DAMAGE_SCROLL_REVERSE:
- grid_render_scroll_reverse(c, buf, &it->item);
+ assert(false);
break;
}
@@ -458,12 +447,10 @@ resize(struct context *c, int width, int height)
LOG_ERRNO("TIOCSWINSZ");
}
- if (c->term.grid.scrolling_region.end == old_rows)
- c->term.grid.scrolling_region.end = c->term.grid.rows;
+ if (c->term.grid.scroll_region.end == old_rows)
+ c->term.grid.scroll_region.end = c->term.grid.rows;
- tll_free(c->term.grid.damage);
- assert(tll_length(c->term.grid.damage) == 0);
- grid_damage_update(&c->term.grid, 0, c->term.grid.rows * c->term.grid.cols);
+ grid_damage_all(&c->term.grid);
if (!c->frame_is_scheduled)
grid_render(c);
diff --git a/terminal.h b/terminal.h
index 5dba62c6..08a0e538 100644
--- a/terminal.h
+++ b/terminal.h
@@ -28,9 +28,12 @@ struct cell {
struct attributes attrs;
};
-enum damage_type {DAMAGE_UPDATE, DAMAGE_UPDATE_NO_SCROLL,
- DAMAGE_ERASE, DAMAGE_ERASE_NO_SCROLL,
- DAMAGE_SCROLL, DAMAGE_SCROLL_REVERSE};
+struct scroll_region {
+ int start;
+ int end;
+};
+
+enum damage_type {DAMAGE_UPDATE, DAMAGE_ERASE, DAMAGE_SCROLL, DAMAGE_SCROLL_REVERSE};
struct damage {
enum damage_type type;
union {
@@ -42,7 +45,7 @@ struct damage {
/* DAMAGE_SCROLL, DAMAGE_SCROLL_REVERSE */
struct {
- int offset;
+ struct scroll_region region;
int lines;
} scroll;
};
@@ -54,12 +57,7 @@ struct grid {
int cell_width;
int cell_height;
- /* Scrolling region - counted as lines excluded from scrolling,
- * from top and from bottom */
- struct {
- int start;
- int end;
- } scrolling_region;
+ struct scroll_region scroll_region;
int linear_cursor;
struct {
@@ -80,6 +78,7 @@ struct grid {
uint32_t background;
tll(struct damage) damage;
+ tll(struct damage) scroll_damage;
};
struct vt_subparams {
diff --git a/vt.c b/vt.c
index 710b706e..b74202bf 100644
--- a/vt.c
+++ b/vt.c
@@ -604,7 +604,7 @@ action(struct terminal *term, enum action action, uint8_t c)
LOG_DBG("execute: 0x%02x", c);
switch (c) {
case '\n':
- if (term->grid.cursor.row == term->grid.scrolling_region.end - 1) {
+ if (term->grid.cursor.row == term->grid.scroll_region.end - 1) {
grid_scroll(&term->grid, 1);
} else
grid_cursor_down(&term->grid, 1);
@@ -638,7 +638,7 @@ action(struct terminal *term, enum action action, uint8_t c)
case ACTION_PRINT: {
if (term->grid.print_needs_wrap) {
- if (term->grid.cursor.row == term->grid.scrolling_region.end - 1) {
+ if (term->grid.cursor.row == term->grid.scroll_region.end - 1) {
grid_scroll(&term->grid, 1);
grid_cursor_to(&term->grid, term->grid.cursor.row, 0);
} else