aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--csi.c65
-rw-r--r--grid.c3
-rw-r--r--grid.h28
-rw-r--r--main.c22
-rw-r--r--render.c213
-rw-r--r--terminal.c142
-rw-r--r--terminal.h34
-rw-r--r--vt.c27
8 files changed, 455 insertions, 79 deletions
diff --git a/csi.c b/csi.c
index a737022f..44d6f8bc 100644
--- a/csi.c
+++ b/csi.c
@@ -338,25 +338,26 @@ csi_dispatch(struct terminal *term, uint8_t final)
/* Erase screen */
int param = param_get(term, 0, 0);
- int start = -1;
- int end = -1;
switch (param) {
case 0:
/* From cursor to end of screen */
- start = term->cursor.linear;
- end = term->cols * term->rows;
+ term_erase(
+ term,
+ &term->cursor,
+ &(struct coord){term->cols - 1, term->rows - 1});
break;
case 1:
/* From start of screen to cursor */
- start = 0;
- end = term->cursor.linear;
+ term_erase(term, &(struct coord){0, 0}, &term->cursor);
break;
case 2:
/* Erase entire screen */
- start = 0;
- end = term->cols * term->rows;
+ term_erase(
+ term,
+ &(struct coord){0, 0},
+ &(struct coord){term->cols - 1, term->rows - 1});
break;
default:
@@ -365,8 +366,6 @@ csi_dispatch(struct terminal *term, uint8_t final)
abort();
break;
}
-
- term_erase(term, start, end);
break;
}
@@ -374,25 +373,27 @@ csi_dispatch(struct terminal *term, uint8_t final)
/* Erase line */
int param = param_get(term, 0, 0);
- int start = -1;
- int end = -1;
switch (param) {
case 0:
/* From cursor to end of line */
- start = term->cursor.linear;
- end = term_cursor_linear(term, term->cursor.row, term->cols);
+ term_erase(
+ term,
+ &term->cursor,
+ &(struct coord){term->cols - 1, term->cursor.row});
break;
case 1:
/* From start of line to cursor */
- start = term_cursor_linear(term, term->cursor.row, 0);
- end = term->cursor.linear;
+ term_erase(
+ term, &(struct coord){0, term->cursor.row}, &term->cursor);
break;
case 2:
/* Entire line */
- start = term_cursor_linear(term, term->cursor.row, 0);
- end = term_cursor_linear(term, term->cursor.row, term->cols);
+ term_erase(
+ term,
+ &(struct coord){0, term->cursor.row},
+ &(struct coord){term->cols - 1, term->cursor.row});
break;
default:
@@ -402,7 +403,6 @@ csi_dispatch(struct terminal *term, uint8_t final)
break;
}
- term_erase(term, start, end);
break;
}
@@ -453,15 +453,25 @@ csi_dispatch(struct terminal *term, uint8_t final)
int remaining = term->cols - (term->cursor.col + count);
/* 'Delete' characters by moving the remaining ones */
- memmove(&term->grid->cur_line[term->cursor.col],
- &term->grid->cur_line[term->cursor.col + count],
- remaining * sizeof(term->grid->cur_line[0]));
+ memmove(&term->grid->cur_row->cells[term->cursor.col],
+ &term->grid->cur_row->cells[term->cursor.col + count],
+ remaining * sizeof(term->grid->cur_row->cells[0]));
+#if 0
term_damage_update(term, term->cursor.linear, remaining);
+#else
+ term->grid->cur_row->dirty = true;
+#endif
/* Erase the remainder of the line */
term_erase(
+ term,
+ &(struct coord){term->cursor.col + remaining, term->cursor.row},
+ &(struct coord){term->cols - 1, term->cursor.row});
+#if 0
+ term_erase(
term, term->cursor.linear + remaining,
term->cursor.linear + remaining + count);
+#endif
break;
}
@@ -478,9 +488,16 @@ csi_dispatch(struct terminal *term, uint8_t final)
int count = min(
param_get(term, 0, 1), term->cols - term->cursor.col);
+ term_erase(
+ term,
+ &term->cursor,
+ &(struct coord){term->cursor.col + count, term->cursor.row});
+
+#if 0
memset(&term->grid->cur_line[term->cursor.col],
0, count * sizeof(term->grid->cur_line[0]));
term_damage_erase(term, term->cursor.linear, count);
+#endif
break;
}
@@ -630,8 +647,8 @@ csi_dispatch(struct terminal *term, uint8_t final)
tll_free(term->alt.damage);
tll_free(term->alt.scroll_damage);
- grid_memclear(term->grid, 0, term->rows * term->cols);
- term_damage_erase(term, 0, term->rows * term->cols);
+ //grid_memclear(term->grid, 0, term->rows * term->cols);
+ //term_damage_erase(term, 0, term->rows * term->cols);
}
break;
diff --git a/grid.c b/grid.c
index c08a002e..b36c5e0b 100644
--- a/grid.c
+++ b/grid.c
@@ -6,7 +6,7 @@
#define LOG_MODULE "grid"
#define LOG_ENABLE_DBG 0
#include "log.h"
-
+#if 0
struct cell *
grid_get_range(struct grid *grid, int start, int *length)
{
@@ -89,3 +89,4 @@ grid_memmove(struct grid *grid, int dst, int src, int length)
copy_idx += count;
}
}
+#endif
diff --git a/grid.h b/grid.h
index 11f38506..d6ddabee 100644
--- a/grid.h
+++ b/grid.h
@@ -3,6 +3,34 @@
#include <stddef.h>
#include "terminal.h"
+static inline struct row *
+grid_row(struct grid *grid, int row)
+{
+ assert(grid->offset >= 0);
+ return grid->rows[(grid->offset + row + grid->num_rows) % grid->num_rows];
+}
+
+static inline void
+grid_swap_row(struct grid *grid, int row_a, int row_b)
+{
+ assert(grid->offset >= 0);
+ assert(row_a != row_b);
+ assert(row_a >= 0);
+ assert(row_b >= 0);
+
+ int real_a = (grid->offset + row_a + grid->num_rows) % grid->num_rows;
+ int real_b = (grid->offset + row_b + grid->num_rows) % grid->num_rows;
+
+ struct row *tmp = grid->rows[real_a];
+ grid->rows[real_a] = grid->rows[real_b];
+ grid->rows[real_b] = tmp;
+
+ grid->rows[real_a]->dirty = true;
+ grid->rows[real_b]->dirty = true;
+}
+
+#if 0
struct cell *grid_get_range(struct grid *grid, int start, int *length);
void grid_memclear(struct grid *grid, int start, int length);
void grid_memmove(struct grid *grid, int dst, int src, int length);
+#endif
diff --git a/main.c b/main.c
index 98fd5045..43507811 100644
--- a/main.c
+++ b/main.c
@@ -589,6 +589,10 @@ out:
wl_pointer_destroy(term.wl.pointer.pointer);
if (term.wl.pointer.surface != NULL)
wl_surface_destroy(term.wl.pointer.surface);
+ if (term.wl.keyboard != NULL)
+ wl_keyboard_destroy(term.wl.keyboard);
+ if (term.wl.seat != NULL)
+ wl_seat_destroy(term.wl.seat);
if (term.wl.surface != NULL)
wl_surface_destroy(term.wl.surface);
if (term.wl.shell != NULL)
@@ -601,9 +605,23 @@ out:
wl_registry_destroy(term.wl.registry);
if (term.wl.display != NULL)
wl_display_disconnect(term.wl.display);
+ if (term.kbd.xkb_keymap != NULL)
+ xkb_keymap_unref(term.kbd.xkb_keymap);
+ if (term.kbd.xkb_state != NULL)
+ xkb_state_unref(term.kbd.xkb_state);
+ if (term.kbd.xkb != NULL)
+ xkb_context_unref(term.kbd.xkb);
- free(term.normal.cells);
- free(term.alt.cells);
+ for (int row = 0; row < term.normal.num_rows; row++) {
+ free(term.normal.rows[row]->cells);
+ free(term.normal.rows[row]);
+ }
+ free(term.normal.rows);
+ for (int row = 0; row < term.alt.num_rows; row++) {
+ free(term.alt.rows[row]->cells);
+ free(term.alt.rows[row]);
+ }
+ free(term.alt.rows);
for (size_t i = 0; i < sizeof(term.fonts) / sizeof(term.fonts[0]); i++) {
if (term.fonts[i] != NULL)
diff --git a/render.c b/render.c
index 0b833376..1376c454 100644
--- a/render.c
+++ b/render.c
@@ -10,6 +10,7 @@
#define LOG_ENABLE_DBG 0
#include "log.h"
#include "shm.h"
+#include "grid.h"
#define min(x, y) ((x) < (y) ? (x) : (y))
#define max(x, y) ((x) > (y) ? (x) : (y))
@@ -33,6 +34,97 @@ struct glyph_sequence {
static struct glyph_sequence gseq;
static void
+render_cell(struct terminal *term, struct buffer *buf, const struct cell *cell,
+ int col, int row)
+{
+ /* Cursor here? */
+ bool has_cursor
+ = (!term->hide_cursor &&
+ (term->cursor.col == col && term->cursor.row == row));
+
+ int width = term->cell_width;
+ int height = term->cell_height;
+ int x = col * width;
+ int y = row * height;
+
+ struct rgba foreground = cell->attrs.have_foreground
+ ? cell->attrs.foreground
+ : !term->reverse ? term->foreground : term->background;
+ struct rgba background = cell->attrs.have_background
+ ? cell->attrs.background
+ : !term->reverse ? term->background : term->foreground;
+
+ if (has_cursor) {
+ struct rgba swap = foreground;
+ foreground = background;
+ background = swap;
+ }
+
+ if (cell->attrs.reverse) {
+ struct rgba swap = foreground;
+ foreground = background;
+ background = swap;
+ }
+
+ /* Background */
+ cairo_set_source_rgba(
+ buf->cairo, background.r, background.g, background.b, background.a);
+ cairo_rectangle(buf->cairo, x, y, width, height);
+ cairo_fill(buf->cairo);
+
+ if (cell->c[0] == '\0' || cell->c[0] == ' ')
+ return;
+
+ if (cell->attrs.conceal)
+ return;
+
+ /*
+ * cairo_show_glyphs() apparently works *much* faster when
+ * called once with a large array of glyphs, compared to
+ * multiple calls with a single glyph.
+ *
+ * So, collect glyphs until cell attributes change, then we
+ * 'flush' (render) the glyphs.
+ */
+
+ if (memcmp(&cell->attrs, &gseq.attrs, sizeof(cell->attrs)) != 0 ||
+ gseq.count >= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]) - 10 ||
+ memcmp(&gseq.foreground, &foreground, sizeof(foreground)) != 0)
+ {
+ if (gseq.count >= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]) - 10)
+ LOG_WARN("hit glyph limit");
+ cairo_set_scaled_font(buf->cairo, attrs_to_font(term, &gseq.attrs));
+ cairo_set_source_rgba(
+ buf->cairo, gseq.foreground.r, gseq.foreground.g,
+ gseq.foreground.b, gseq.foreground.a);
+
+ cairo_set_operator(buf->cairo, CAIRO_OPERATOR_OVER);
+ cairo_show_glyphs(buf->cairo, gseq.glyphs, gseq.count);
+
+ gseq.g = gseq.glyphs;
+ gseq.count = 0;
+ gseq.attrs = cell->attrs;
+ gseq.foreground = foreground;
+ }
+
+ int new_glyphs
+ = sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]) - gseq.count;
+
+ cairo_status_t status = cairo_scaled_font_text_to_glyphs(
+ attrs_to_font(term, &cell->attrs), x, y + term->fextents.ascent,
+ cell->c, strlen(cell->c), &gseq.g, &new_glyphs,
+ NULL, NULL, NULL);
+
+ if (status != CAIRO_STATUS_SUCCESS)
+ return;
+
+ gseq.g += new_glyphs;
+ gseq.count += new_glyphs;
+ assert(gseq.count <= sizeof(gseq.glyphs) / sizeof(gseq.glyphs[0]));
+}
+
+#if 0
+static void
grid_render_update(struct terminal *term, struct buffer *buf, const struct damage *dmg)
{
LOG_DBG("damage: UPDATE: %d -> %d (offset = %d)",
@@ -249,6 +341,7 @@ grid_render_erase(struct terminal *term, struct buffer *buf, const struct damage
wl_surface_damage_buffer(term->wl.surface, x, y, width, height);
}
}
+#endif
static void
grid_render_scroll(struct terminal *term, struct buffer *buf,
@@ -278,6 +371,7 @@ grid_render_scroll(struct terminal *term, struct buffer *buf,
wl_surface_damage_buffer(term->wl.surface, 0, dst_y, width, height);
}
+#if 0
const int cols = term->cols;
struct damage erase = {
@@ -290,6 +384,7 @@ grid_render_scroll(struct terminal *term, struct buffer *buf,
},
};
grid_render_erase(term, buf, &erase);
+#endif
}
static void
@@ -320,6 +415,7 @@ grid_render_scroll_reverse(struct terminal *term, struct buffer *buf,
wl_surface_damage_buffer(term->wl.surface, 0, dst_y, width, height);
}
+#if 0
const int cols = term->cols;
struct damage erase = {
@@ -331,6 +427,7 @@ grid_render_scroll_reverse(struct terminal *term, struct buffer *buf,
},
};
grid_render_erase(term, buf, &erase);
+#endif
}
static void frame_callback(
@@ -345,16 +442,19 @@ grid_render(struct terminal *term)
{
static int last_cursor;
+#if 0
if (tll_length(term->grid->damage) == 0 &&
tll_length(term->grid->scroll_damage) == 0 &&
last_cursor == term->grid->offset + term->cursor.linear)
{
return;
}
-
+#endif
assert(term->width > 0);
assert(term->height > 0);
+ //LOG_WARN("RENDER");
+
struct buffer *buf = shm_get_buffer(term->wl.shm, term->width, term->height);
cairo_set_operator(buf->cairo, CAIRO_OPERATOR_SOURCE);
@@ -388,6 +488,8 @@ grid_render(struct terminal *term)
last_buf = buf;
}
+ bool all_clean = tll_length(term->grid->scroll_damage) == 0;
+
tll_foreach(term->grid->scroll_damage, it) {
switch (it->item.type) {
case DAMAGE_SCROLL:
@@ -409,7 +511,7 @@ grid_render(struct terminal *term)
gseq.g = gseq.glyphs;
gseq.count = 0;
-
+#if 0
tll_foreach(term->grid->damage, it) {
switch (it->item.type) {
case DAMAGE_ERASE: grid_render_erase(term, buf, &it->item); break;
@@ -423,24 +525,77 @@ grid_render(struct terminal *term)
tll_remove(term->grid->damage, it);
}
+#endif
+
+ for (int r = 0; r < term->rows; r++) {
+ struct row *row = grid_row(term->grid, r);
+
+ if (!row->dirty)
+ continue;
+
+ //LOG_WARN("rendering line: %d", r);
+
+ for (int col = 0; col < term->cols; col++)
+ render_cell(term, buf, &row->cells[col], col, r);
+
+ row->dirty = false;
+ all_clean = false;
+
+ wl_surface_damage_buffer(term->wl.surface, 0, r * term->cell_height, term->width, term->cell_height);
+ }
/* TODO: break out to function */
/* Re-render last cursor cell and current cursor cell */
/* Make sure previous cursor is refreshed (to avoid "ghost" cursors) */
- if (last_cursor != term->cursor.linear) {
+ int cursor_as_linear
+ = (term->grid->offset + term->cursor.row) * term->cols + term->cursor.col;
+
+ if (last_cursor != cursor_as_linear) {
+#if 0
struct damage prev_cursor = {
.type = DAMAGE_UPDATE,
.range = {.start = last_cursor, .length = 1},
};
grid_render_update(term, buf, &prev_cursor);
+#endif
+#if 1
+ int row = last_cursor / term->cols - term->grid->offset;
+ int col = last_cursor % term->cols;
+ if (row >= 0 && row < term->rows) {
+ render_cell(term, buf, &grid_row(term->grid, row)->cells[col], col, row);
+ all_clean = false;
+
+ wl_surface_damage_buffer(
+ term->wl.surface, col * term->cell_width, row * term->cell_height,
+ term->cell_width, term->cell_height);
+ }
+ last_cursor = cursor_as_linear;
+#endif
+ }
+
+ if (all_clean) {
+ buf->busy = false;
+ return;
}
+#if 0
struct damage cursor = {
.type = DAMAGE_UPDATE,
.range = {.start = term->grid->offset + term->cursor.linear, .length = 1},
};
grid_render_update(term, buf, &cursor);
- last_cursor = term->grid->offset + term->cursor.linear;
+#endif
+
+ render_cell(
+ term, buf,
+ &grid_row(term->grid, term->cursor.row)->cells[term->cursor.col],
+ term->cursor.col, term->cursor.row);
+
+ wl_surface_damage_buffer(
+ term->wl.surface,
+ term->cursor.col * term->cell_width,
+ term->cursor.row * term->cell_height,
+ term->cell_width, term->cell_height);
if (gseq.count > 0) {
cairo_set_scaled_font(buf->cairo, attrs_to_font(term, &gseq.attrs));
@@ -451,9 +606,11 @@ grid_render(struct terminal *term)
cairo_show_glyphs(buf->cairo, gseq.glyphs, gseq.count);
}
+#if 0
term->grid->offset %= term->grid->size;
if (term->grid->offset < 0)
term->grid->offset += term->grid->size;
+#endif
//cairo_surface_flush(buf->cairo_surface);
wl_surface_attach(term->wl.surface, buf->wl_buf, 0, 0);
@@ -485,6 +642,7 @@ render_resize(struct terminal *term, int width, int height)
term->width = width;
term->height = height;
+#if 0
const size_t old_rows = term->rows;
const size_t normal_old_size = term->normal.size;
const size_t alt_old_size = term->alt.size;
@@ -522,6 +680,49 @@ render_resize(struct terminal *term, int width, int height)
.background = term->background},
};
}
+#endif
+ //const int old_cols = term->cols;
+ const int old_rows = term->rows;
+ const int new_cols = term->width / term->cell_width;
+ const int new_rows = term->height / term->cell_height;
+
+ for (int r = 0; r < term->normal.num_rows; r++) {
+ free(term->normal.rows[r]->cells);
+ free(term->normal.rows[r]);
+ }
+ free(term->normal.rows);
+
+ for (int r = 0; r < term->alt.num_rows; r++) {
+ free(term->alt.rows[r]->cells);
+ free(term->alt.rows[r]);
+ }
+ free(term->alt.rows);
+
+ /* TODO: reflow old content */
+ term->normal.num_rows = new_rows;
+ term->normal.offset = 0;
+ term->alt.num_rows = new_rows;
+ term->alt.offset = 0;
+
+ term->normal.rows = malloc(
+ term->normal.num_rows * sizeof(term->normal.rows[0]));
+ for (int r = 0; r < term->normal.num_rows; r++) {
+ struct row *row = malloc(sizeof(*row));
+ row->cells = calloc(new_cols, sizeof(row->cells[0]));
+ row->dirty = true;
+ term->normal.rows[r] = row;
+ }
+
+ term->alt.rows = malloc(term->alt.num_rows * sizeof(term->alt.rows[0]));
+ for (int r = 0; r < term->alt.num_rows; r++) {
+ struct row *row = malloc(sizeof(*row));
+ row->cells = calloc(new_cols, sizeof(row->cells[0]));
+ row->dirty = true;
+ term->alt.rows[r] = row;
+ }
+
+ term->cols = new_cols;
+ term->rows = new_rows;
LOG_INFO("resize: %dx%d, grid: cols=%d, rows=%d",
term->width, term->height, term->cols, term->rows);
@@ -540,10 +741,14 @@ render_resize(struct terminal *term, int width, int height)
if (term->scroll_region.end == old_rows)
term->scroll_region.end = term->rows;
+#if 0
term_cursor_to(
term,
min(term->cursor.row, term->rows - 1),
min(term->cursor.col, term->cols - 1));
+#endif
+ term->cursor.row = term->cursor.col = 0;
+ term->grid->cur_row = grid_row(term->grid, 0);
term_damage_all(term);
diff --git a/terminal.c b/terminal.c
index 7c15ce87..7630c25e 100644
--- a/terminal.c
+++ b/terminal.c
@@ -12,6 +12,7 @@
#define min(x, y) ((x) < (y) ? (x) : (y))
#define max(x, y) ((x) > (y) ? (x) : (y))
+#if 0
static bool
damage_merge_range(struct terminal *term, const struct damage *dmg)
{
@@ -66,27 +67,36 @@ term_damage_update_or_erase(struct terminal *term, enum damage_type damage_type,
tll_push_back(term->grid->damage, dmg);
}
-
+#endif
void
term_damage_update(struct terminal *term, int start, int length)
{
+#if 0
assert(start + length <= term->rows * term->cols);
term_damage_update_or_erase(term, DAMAGE_UPDATE, start, length);
+#endif
}
void
term_damage_erase(struct terminal *term, int start, int length)
{
+#if 0
assert(start + length <= term->rows * term->cols);
term_damage_update_or_erase(term, DAMAGE_ERASE, start, length);
+#endif
}
void
term_damage_all(struct terminal *term)
{
+#if 0
tll_free(term->grid->damage);
tll_free(term->grid->scroll_damage);
term_damage_update(term, 0, term->rows * term->cols);
+#else
+ for (int i = 0; i < term->rows; i++)
+ grid_row(term->grid, i)->dirty = true;
+#endif
}
#if 0
@@ -119,6 +129,7 @@ void
term_damage_scroll(struct terminal *term, enum damage_type damage_type,
struct scroll_region region, int lines)
{
+#if 0
//damage_adjust_after_scroll(term, damage_type, region, lines);
if (damage_type == DAMAGE_SCROLL) {
tll_foreach(term->grid->damage, it) {
@@ -136,7 +147,7 @@ term_damage_scroll(struct terminal *term, enum damage_type damage_type,
break;
}
}
-
+#endif
if (tll_length(term->grid->scroll_damage) > 0) {
struct damage *dmg = &tll_back(term->grid->scroll_damage);
@@ -155,6 +166,7 @@ term_damage_scroll(struct terminal *term, enum damage_type damage_type,
tll_push_back(term->grid->scroll_damage, dmg);
}
+#if 0
void
term_erase(struct terminal *term, int start, int end)
{
@@ -187,41 +199,75 @@ term_erase(struct terminal *term, int start, int end)
term_damage_erase(term, start, end - start);
}
}
+#else
+static inline void
+erase_cell_range(struct terminal *term, struct row *row, int start, int end)
+{
+ assert(start < term->cols);
+ assert(end < term->cols);
+
+ if (unlikely(term->vt.attrs.have_background)) {
+ for (int col = start; col <= end; col++) {
+ row->cells[col].c[0] = '\0';
+ row->cells[col].attrs.have_background = true;
+ row->cells[col].attrs.background = term->vt.attrs.background;
+ }
+ } else {
+ memset(&row->cells[start], 0, (end - start + 1) * sizeof(row->cells[0]));
+ }
+ row->dirty = true;
+}
-int
-term_cursor_linear(const struct terminal *term, int row, int col)
+static inline void
+erase_line(struct terminal *term, struct row *row)
{
- return row * term->cols + col;
+ erase_cell_range(term, row, 0, term->cols - 1);
}
void
+term_erase(struct terminal *term, const struct coord *start, const struct coord *end)
+{
+ assert(start->row <= end->row);
+ assert(start->col <= end->col || start->row < end->row);
+
+ if (start->row == end->row) {
+ struct row *row = grid_row(term->grid, start->row);
+ erase_cell_range(term, row, start->col, end->col);
+ return;
+ }
+
+ assert(end->row > start->row);
+
+ erase_cell_range(
+ term, grid_row(term->grid, start->row), start->col, term->cols - 1);
+
+ for (int r = start->row + 1; r < end->row; r++)
+ erase_line(term, grid_row(term->grid, r));
+
+ erase_cell_range(term, grid_row(term->grid, end->row), 0, end->col);
+}
+#endif
+
+void
term_cursor_to(struct terminal *term, int row, int col)
{
assert(row < term->rows);
assert(col < term->cols);
- int new_linear = row * term->cols + col;
- assert(new_linear < term->rows * term->cols);
-
term->print_needs_wrap = false;
- term->cursor.linear = new_linear;
term->cursor.col = col;
term->cursor.row = row;
- int len = term->cols;
- term->grid->cur_line = grid_get_range(
- term->grid, term->cursor.linear - col, &len);
-
- assert(len == term->cols);
+ term->grid->cur_row = grid_row(term->grid, row);
}
void
term_cursor_left(struct terminal *term, int count)
{
int move_amount = min(term->cursor.col, count);
- term->cursor.linear -= move_amount;
term->cursor.col -= move_amount;
+ assert(term->cursor.col >= 0);
term->print_needs_wrap = false;
}
@@ -229,8 +275,8 @@ void
term_cursor_right(struct terminal *term, int count)
{
int move_amount = min(term->cols - term->cursor.col - 1, count);
- term->cursor.linear += move_amount;
term->cursor.col += move_amount;
+ assert(term->cursor.col < term->cols);
term->print_needs_wrap = false;
}
@@ -253,12 +299,13 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows
{
LOG_DBG("scroll: %d rows", rows);
- if (region.start > 0) {
- /* TODO: check if it's worth memoving the scroll area instead,
- * under certain circumstances */
+ assert(rows < term->rows && "unimplemented");
- grid_memmove(term->grid, rows * term->cols, 0, region.start * term->cols);
+ for (int i = region.start - 1; i >= 0; i--)
+ grid_swap_row(term->grid, i, i + rows);
+ if (region.start > 0) {
+#if 0
tll_foreach(term->grid->damage, it) {
int start = it->item.range.start - term->grid->offset;
int end __attribute__((unused)) = start + it->item.range.length;
@@ -268,16 +315,22 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows
it->item.range.start += rows * term->cols;
}
}
+#endif
}
+ for (int i = term->rows - 1; i >= region.end; i--)
+ grid_swap_row(term->grid, i, i + rows);
+
if (region.end < term->rows) {
- /* Copy scrolled-up bottom region to new bottom region */
+#if 0
grid_memmove(
term->grid,
(region.end + rows) * term->cols,
region.end * term->cols,
(term->rows - region.end) * term->cols);
+#endif
+#if 0
tll_foreach(term->grid->damage, it) {
int start = it->item.range.start - term->grid->offset;
int end = start + it->item.range.length;
@@ -287,24 +340,33 @@ term_scroll_partial(struct terminal *term, struct scroll_region region, int rows
it->item.range.start += rows * term->cols;
}
}
+#endif
}
/* Offset grid origin */
- term->grid->offset += rows * term->cols;
+ term->grid->offset += rows;
+ term->grid->offset %= term->grid->num_rows;
- /* Clear scrolled-in lines */
- grid_memclear(
- term->grid,
- max(0, region.end - rows) * term->cols,
- min(rows, term->rows) * term->cols);
+#if 0
+ term_erase(
+ term,
+ &(struct coord){0, max(region.end - rows, 0)},
+ &(struct coord){term->cols - 1, region.end - 1});
+#else
+ for (int r = max(region.end - rows, 0); r < region.end; r++)
+ erase_line(term, grid_row(term->grid, r));
+#endif
term_damage_scroll(term, DAMAGE_SCROLL, region, rows);
+ term->grid->cur_row = grid_row(term->grid, term->cursor.row);
+#if 0
int len = term->cols;
term->grid->cur_line = grid_get_range(
term->grid, term->cursor.linear - term->cursor.col, &len);
assert(len == term->cols);
+#endif
}
void
@@ -317,7 +379,11 @@ void
term_scroll_reverse_partial(struct terminal *term,
struct scroll_region region, int rows)
{
+ assert(rows < term->rows && "unimplemented");
+
if (region.end < term->rows) {
+ //assert(false);
+#if 0
grid_memmove(
term->grid,
(region.end - rows) * term->cols,
@@ -333,10 +399,12 @@ term_scroll_reverse_partial(struct terminal *term,
it->item.range.start -= rows * term->cols;
}
}
-
+#endif
}
if (region.start > 0) {
+ //assert(false);
+#if 0
grid_memmove(
term->grid, -rows * term->cols, 0, region.start * term->cols);
@@ -354,19 +422,31 @@ term_scroll_reverse_partial(struct terminal *term,
it->item.range.start -= rows * term->cols;
}
}
+#endif
}
- term->grid->offset -= rows * term->cols;
+ term->grid->offset += term->grid->num_rows - rows;
+ term->grid->offset %= term->grid->num_rows;
- grid_memclear(term->grid, region.start * term->cols, rows * term->cols);
+ for (int i = region.end + rows; i < term->rows + rows; i++)
+ grid_swap_row(term->grid, i, i - rows);
+ for (int i = 0 + rows; i < region.start + rows; i++)
+ grid_swap_row(term->grid, i, i - rows);
- term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows);
+ term_erase(
+ term,
+ &(struct coord){0, region.start},
+ &(struct coord){term->cols - 1, min(region.start + rows, region.end) - 1});
+ term_damage_scroll(term, DAMAGE_SCROLL_REVERSE, region, rows);
+ term->grid->cur_row = grid_row(term->grid, term->cursor.row);
+#if 0
int len = term->cols;
term->grid->cur_line = grid_get_range(
term->grid, term->cursor.linear - term->cursor.col, &len);
assert(len == term->cols);
+#endif
}
void
diff --git a/terminal.h b/terminal.h
index ddc37410..253163af 100644
--- a/terminal.h
+++ b/terminal.h
@@ -74,10 +74,9 @@ struct scroll_region {
int end;
};
-struct cursor {
- int row;
+struct coord {
int col;
- int linear;
+ int row;
};
enum damage_type {DAMAGE_UPDATE, DAMAGE_ERASE, DAMAGE_SCROLL, DAMAGE_SCROLL_REVERSE};
@@ -85,10 +84,12 @@ struct damage {
enum damage_type type;
union {
/* DAMAGE_UPDATE, DAMAGE_ERASE */
+#if 0
struct {
int start;
int length;
} range;
+#endif
/* DAMAGE_SCROLL, DAMAGE_SCROLL_REVERSE */
struct {
@@ -98,12 +99,19 @@ struct damage {
};
};
+struct row {
+ struct cell *cells;
+ bool dirty;
+};
+
struct grid {
- int size;
+ int num_rows;
int offset;
- struct cell *cells;
- struct cell *cur_line;
+ //struct cell *cells;
+ //struct cell *cur_line;
+ struct row **rows;
+ struct row *cur_row;
tll(struct damage) damage;
tll(struct damage) scroll_damage;
@@ -227,14 +235,14 @@ struct terminal {
struct rgba background;
struct {
- int row;
int col;
+ int row;
int button;
} mouse;
- struct cursor cursor;
- struct cursor saved_cursor;
- struct cursor alt_saved_cursor;
+ struct coord cursor;
+ struct coord saved_cursor;
+ struct coord alt_saved_cursor;
struct grid normal;
struct grid alt;
@@ -254,7 +262,9 @@ void term_damage_scroll(
struct terminal *term, enum damage_type damage_type,
struct scroll_region region, int lines);
-void term_erase(struct terminal *term, int start, int end);
+//void term_erase(struct terminal *term, int start, int end);
+void term_erase(
+ struct terminal *term, const struct coord *start, const struct coord *end);
void term_cursor_to(struct terminal *term, int row, int col);
void term_cursor_left(struct terminal *term, int count);
@@ -270,8 +280,6 @@ void term_scroll_partial(
void term_scroll_reverse_partial(
struct terminal *term, struct scroll_region region, int rows);
-int term_cursor_linear(const struct terminal *term, int row, int col);
-
void term_mouse_down(struct terminal *term, int button, int row, int col,
bool shift, bool alt, bool ctrl);
void term_mouse_up(struct terminal *term, int button, int row, int col,
diff --git a/vt.c b/vt.c
index 7bab63d1..7ce2ddcb 100644
--- a/vt.c
+++ b/vt.c
@@ -658,6 +658,7 @@ pre_print(struct terminal *term)
static inline void
post_print(struct terminal *term)
{
+ term->grid->cur_row->dirty = true;
if (term->cursor.col < term->cols - 1)
term_cursor_right(term, 1);
else
@@ -669,11 +670,19 @@ print_insert(struct terminal *term)
{
if (unlikely(term->insert_mode)) {
assert(false && "untested");
- grid_memmove(
- term->grid, term->cursor.linear + 1, term->cursor.linear,
+
+ struct row *row = term->grid->cur_row;
+ memmove(
+ &row[term->cursor.col + 1],
+ &row[term->cursor.col],
term->cols - term->cursor.col - 1);
+
+#if 0
term_damage_update(
term, term->cursor.linear + 1, term->cols - term->cursor.col - 1);
+#else
+ row->dirty = true;
+#endif
}
}
@@ -682,8 +691,13 @@ action_print_utf8(struct terminal *term)
{
pre_print(term);
- struct cell *cell = &term->grid->cur_line[term->cursor.col];
+ struct row *row = term->grid->cur_row;
+ struct cell *cell = &row->cells[term->cursor.col];
+#if 0
term_damage_update(term, term->cursor.linear, 1);
+#else
+ row->dirty = true;
+#endif
print_insert(term);
@@ -701,8 +715,13 @@ action_print(struct terminal *term, uint8_t c)
{
pre_print(term);
- struct cell *cell = &term->grid->cur_line[term->cursor.col];
+ struct row *row = term->grid->cur_row;
+ struct cell *cell = &row->cells[term->cursor.col];
+#if 0
term_damage_update(term, term->cursor.linear, 1);
+#else
+ row->dirty = true;
+#endif
print_insert(term);