From d706e6828062aa35505d3893fb3c04b84985aa29 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Fri, 3 Jan 2020 23:29:45 +0100 Subject: selection: track selection type; normal or block selection --- selection.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index 2da2ba03..6efe682c 100644 --- a/selection.c +++ b/selection.c @@ -126,14 +126,19 @@ extract_selection(const struct terminal *term) } void -selection_start(struct terminal *term, int col, int row) +selection_start(struct terminal *term, int col, int row, + enum selection_kind kind) { if (!selection_enabled(term)) return; selection_cancel(term); - LOG_DBG("selection started at %d,%d", row, col); + LOG_DBG("%s selection started at %d,%d", + kind == SELECTION_NORMAL ? "normal" : + kind == SELECTION_BLOCK ? "block" : "", + row, col); + term->selection.kind = kind; term->selection.start = (struct coord){col, term->grid->view + row}; term->selection.end = (struct coord){-1, -1}; } @@ -287,7 +292,7 @@ selection_mark_word(struct terminal *term, int col, int row, bool spaces_only, } } - selection_start(term, start.col, start.row); + selection_start(term, start.col, start.row, SELECTION_NORMAL); selection_update(term, end.col, end.row); selection_finalize(term, serial); } @@ -295,7 +300,7 @@ selection_mark_word(struct terminal *term, int col, int row, bool spaces_only, void selection_mark_row(struct terminal *term, int row, uint32_t serial) { - selection_start(term, 0, row); + selection_start(term, 0, row, SELECTION_NORMAL); selection_update(term, term->cols - 1, row); selection_finalize(term, serial); } -- cgit v1.3 From f12b1473fde2045d38750aa1051ad624e0fea2bc Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 12:03:04 +0100 Subject: selection: store cell 'selected' state in the cells' attributes Instead of having the renderer calculate, for each cell, whether that cell is currently selected or not, make selection_update() mark/unmark the selected cells. The renderer now only has to look at the cells' 'selected' attribute. This makes the renderer both smaller and faster. --- render.c | 61 ++++---------------------- selection.c | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++---------- terminal.h | 3 +- 3 files changed, 129 insertions(+), 78 deletions(-) (limited to 'selection.c') diff --git a/render.c b/render.c index 755304ea..d97da212 100644 --- a/render.c +++ b/render.c @@ -275,13 +275,14 @@ draw_strikeout(const struct terminal *term, pixman_image_t *pix, static void draw_cursor(const struct terminal *term, const struct cell *cell, - bool is_selected, const struct font *font, - pixman_image_t *pix, pixman_color_t *fg, const pixman_color_t *bg, - int x, int y, int cols) + const struct font *font, pixman_image_t *pix, pixman_color_t *fg, + const pixman_color_t *bg, int x, int y, int cols) { pixman_color_t cursor_color; pixman_color_t text_color; + bool is_selected = cell->attrs.selected; + if (term->cursor_color.cursor >> 31) { assert(term->cursor_color.text); @@ -331,51 +332,6 @@ draw_cursor(const struct terminal *term, const struct cell *cell, } } -static bool -coord_is_selected(const struct terminal *term, int col, int row) -{ - if (term->selection.start.col == -1 || term->selection.end.col == -1) - return false; - - const struct coord *start = &term->selection.start; - const struct coord *end = &term->selection.end; - - if (start->row > end->row || (start->row == end->row && start->col > end->col)) { - const struct coord *tmp = start; - start = end; - end = tmp; - } - - assert(start->row <= end->row); - - row += term->grid->view; - - switch (term->selection.kind) { - case SELECTION_NORMAL: - if (start->row == end->row) { - return row == start->row && col >= start->col && col <= end->col; - } else { - if (row == start->row) - return col >= start->col; - else if (row == end->row) - return col <= end->col; - else - return row >= start->row && row <= end->row; - } - - case SELECTION_BLOCK: - if (start->col <= end->col) - return row >= start->row && row <= end->row && - col >= start->col && col <= end->col; - else - return row >= start->row && row <= end->row && - col <= start->col && col >= end->col; - } - - assert(false); - return false; -} - static int render_cell(struct terminal *term, pixman_image_t *pix, struct cell *cell, int col, int row, bool has_cursor) @@ -390,7 +346,8 @@ render_cell(struct terminal *term, pixman_image_t *pix, int x = term->x_margin + col * width; int y = term->y_margin + row * height; - bool is_selected = coord_is_selected(term, col, row); + //bool is_selected = coord_is_selected(term, col, row); + bool is_selected = cell->attrs.selected; uint32_t _fg = 0; uint32_t _bg = 0; @@ -430,10 +387,8 @@ render_cell(struct terminal *term, pixman_image_t *pix, PIXMAN_OP_SRC, pix, &bg, 1, &(pixman_rectangle16_t){x, y, cell_cols * width, height}); - if (has_cursor) { - draw_cursor( - term, cell, is_selected, font, pix, &fg, &bg, x, y, cell_cols); - } + if (has_cursor) + draw_cursor(term, cell, font, pix, &fg, &bg, x, y, cell_cols); if (cell->attrs.blink) term_arm_blink_timer(term); diff --git a/selection.c b/selection.c index 6efe682c..1510210e 100644 --- a/selection.c +++ b/selection.c @@ -45,6 +45,92 @@ selection_on_row_in_view(const struct terminal *term, int row_no) return row_no >= start->row && row_no <= end->row; } +static void +foreach_selected_normal( + struct terminal *term, + void (*cb)(struct terminal *term, struct row *row, struct cell *cell, void *data), + void *data) +{ + const struct coord *start = &term->selection.start; + const struct coord *end = &term->selection.end; + + int start_row, end_row; + int start_col, end_col; + + if (start->row < end->row) { + start_row = start->row; + end_row = end->row; + start_col = start->col; + end_col = end->col; + } else if (start->row > end->row) { + start_row = end->row; + end_row = start->row; + start_col = end->col; + end_col = start->col; + } else { + start_row = end_row = start->row; + start_col = min(start->col, end->col); + end_col = max(start->col, end->col); + } + + for (int r = start_row; r <= end_row; r++) { + struct row *row = term->grid->rows[r]; + + for (int c = start_col; + c <= (r == end_row ? end_col : term->cols - 1); + c++) + { + cb(term, row, &row->cells[c], data); + } + + start_col = 0; + } +} + +static void +foreach_selected_block( + struct terminal *term, + void (*cb)(struct terminal *term, struct row *row, struct cell *cell, void *data), + void *data) +{ + const struct coord *start = &term->selection.start; + const struct coord *end = &term->selection.end; + + struct coord top_left = { + .row = min(start->row, end->row), + .col = min(start->col, end->col), + }; + + struct coord bottom_right = { + .row = max(start->row, end->row), + .col = max(start->col, end->col), + }; + + for (int r = top_left.row; r <= bottom_right.row; r++) { + struct row *row = term->grid->rows[r]; + + for (int c = top_left.col; c <= bottom_right.col; c++) + cb(term, row, &row->cells[c], data); + } +} + +static void +foreach_selected( + struct terminal *term, + void (*cb)(struct terminal *term, struct row *row, struct cell *cell, void *data), + void *data) +{ + switch (term->selection.kind) { + case SELECTION_NORMAL: + return foreach_selected_normal(term, cb, data); + + case SELECTION_BLOCK: + return foreach_selected_block(term, cb, data); + } + + assert(false); +} + static char * extract_selection(const struct terminal *term) { @@ -143,6 +229,30 @@ selection_start(struct terminal *term, int col, int row, term->selection.end = (struct coord){-1, -1}; } +static void +unmark_selected(struct terminal *term, struct row *row, struct cell *cell, + void *data) +{ + if (!cell->attrs.selected) + return; + + row->dirty = 1; + cell->attrs.selected = 0; + cell->attrs.clean = 0; +} + +static void +mark_selected(struct terminal *term, struct row *row, struct cell *cell, + void *data) +{ + if (cell->attrs.selected) + return; + + row->dirty = 1; + cell->attrs.selected = 1; + cell->attrs.clean = 0; +} + void selection_update(struct terminal *term, int col, int row) { @@ -154,24 +264,16 @@ selection_update(struct terminal *term, int col, int row) term->selection.end.row, term->selection.end.col, row, col); - int start_row = term->selection.start.row; - int old_end_row = term->selection.end.row; - int new_end_row = term->grid->view + row; - - assert(start_row != -1); - assert(new_end_row != -1); - - if (old_end_row == -1) - old_end_row = new_end_row; + assert(term->selection.start.row != -1); + assert(term->grid->view + row != -1); - int from = min(start_row, min(old_end_row, new_end_row)); - int to = max(start_row, max(old_end_row, new_end_row)); + if (term->selection.end.row != -1) + foreach_selected(term, &unmark_selected, NULL); term->selection.end = (struct coord){col, term->grid->view + row}; assert(term->selection.start.row != -1 && term->selection.end.row != -1); - term_damage_rows_in_view(term, from - term->grid->view, to - term->grid->view); - + foreach_selected(term, &mark_selected, NULL); render_refresh(term); } @@ -212,20 +314,13 @@ selection_cancel(struct terminal *term) term->selection.start.row, term->selection.start.col, term->selection.end.row, term->selection.end.col); - int start_row = term->selection.start.row; - int end_row = term->selection.end.row; + if (term->selection.start.row != -1 && term->selection.end.row != -1) { + foreach_selected(term, &unmark_selected, NULL); + render_refresh(term); + } term->selection.start = (struct coord){-1, -1}; term->selection.end = (struct coord){-1, -1}; - - if (start_row != -1 && end_row != -1) { - term_damage_rows_in_view( - term, - min(start_row, end_row) - term->grid->view, - max(start_row, end_row) - term->grid->view); - - render_refresh(term); - } } void diff --git a/terminal.h b/terminal.h index e0b8d44a..4bc4d092 100644 --- a/terminal.h +++ b/terminal.h @@ -41,7 +41,8 @@ struct attributes { uint32_t clean:1; uint32_t have_fg:1; uint32_t have_bg:1; - uint32_t reserved:5; + uint32_t selected:1; + uint32_t reserved:4; uint32_t bg:24; }; static_assert(sizeof(struct attributes) == 8, "bad size"); -- cgit v1.3 From 2a531327dde3c86edea2baf9503d08545d8f4767 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 12:09:09 +0100 Subject: selection: selection_cancel() now sets 'kind' to SELECTION_NONE --- selection.c | 5 +++++ terminal.h | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index 1510210e..b9f4579e 100644 --- a/selection.c +++ b/selection.c @@ -126,6 +126,10 @@ foreach_selected( case SELECTION_BLOCK: return foreach_selected_block(term, cb, data); + + case SELECTION_NONE: + assert(false); + return; } assert(false); @@ -319,6 +323,7 @@ selection_cancel(struct terminal *term) render_refresh(term); } + term->selection.kind = SELECTION_NONE; term->selection.start = (struct coord){-1, -1}; term->selection.end = (struct coord){-1, -1}; } diff --git a/terminal.h b/terminal.h index 4bc4d092..9d28ff41 100644 --- a/terminal.h +++ b/terminal.h @@ -158,7 +158,7 @@ enum mouse_reporting { enum cursor_style { CURSOR_BLOCK, CURSOR_UNDERLINE, CURSOR_BAR }; -enum selection_kind { SELECTION_NORMAL, SELECTION_BLOCK }; +enum selection_kind { SELECTION_NONE, SELECTION_NORMAL, SELECTION_BLOCK }; struct ptmx_buffer { void *data; -- cgit v1.3 From 975a35ae16949495076c3377573e906422de97ba Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 12:59:29 +0100 Subject: selection: extract_selection now uses foreach_selected() This "automagically" adds support for block selections, since foreach_selected already handles block selections. --- selection.c | 166 +++++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 107 insertions(+), 59 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index b9f4579e..1ecf6a7a 100644 --- a/selection.c +++ b/selection.c @@ -135,84 +135,132 @@ foreach_selected( assert(false); } -static char * -extract_selection(const struct terminal *term) +static size_t +selection_cell_count(const struct terminal *term) { const struct coord *start = &term->selection.start; const struct coord *end = &term->selection.end; - assert(start->row <= end->row); + switch (term->selection.kind) { + case SELECTION_NONE: + return 0; - size_t max_cells = 0; - if (start->row == end->row) { - assert(start->col <= end->col); - max_cells = end->col - start->col + 1; - } else { - max_cells = term->cols - start->col; - max_cells += term->cols * (end->row - start->row - 1); - max_cells += end->col + 1; + case SELECTION_NORMAL: + if (term->selection.end.row == -1) + return 0; + + assert(term->selection.start.row != -1); + + if (start->row > end->row) { + const struct coord *tmp = start; + start = end; + end = tmp; + } + + if (start->row == end->row) + return end->col - start->col + 1; + else { + size_t cells = term->cols - start->col; + cells += term->cols * (end->row - start->row - 1); + cells += end->col + 1; + return cells; + } + + case SELECTION_BLOCK: { + struct coord top_left = { + .row = min(start->row, end->row), + .col = min(start->col, end->col), + }; + + struct coord bottom_right = { + .row = max(start->row, end->row), + .col = max(start->col, end->col), + }; + + int cols = bottom_right.col - top_left.col + 1; + int rows = bottom_right.row - top_left.row + 1; + return rows * cols; + } } - const size_t buf_size = max_cells * 4 + 1; - char *buf = malloc(buf_size); - int idx = 0; - - int start_col = start->col; - for (int r = start->row; r <= end->row; r++) { - const struct row *row = grid_row_in_view(term->grid, r - term->grid->view); - if (row == NULL) - continue; - - /* - * Trailing empty cells are never included in the selection. - * - * Empty cells between non-empty cells however are replaced - * with spaces. - */ - - for (int col = start_col, empty_count = 0; - col <= (r == end->row ? end->col : term->cols - 1); - col++) - { - const struct cell *cell = &row->cells[col]; + assert(false); + return 0; +} - if (cell->wc == 0) { - empty_count++; - if (col == term->cols - 1) - buf[idx++] = '\n'; - continue; - } +struct extract { + char *buf; + size_t size; + size_t idx; + size_t empty_count; + struct row *last_row; + struct cell *last_cell; +}; + +static void +extract_one(struct terminal *term, struct row *row, struct cell *cell, + void *data) +{ + struct extract *ctx = data; - assert(idx + empty_count <= buf_size); - memset(&buf[idx], ' ', empty_count); - idx += empty_count; - empty_count = 0; + if (ctx->last_row != NULL && row != ctx->last_row && + ((term->selection.kind == SELECTION_NORMAL && ctx->last_cell->wc == 0) || + term->selection.kind == SELECTION_BLOCK)) + { + /* Last cell was the last column in the selection */ + ctx->buf[ctx->idx++] = '\n'; + ctx->empty_count = 0; + } - assert(idx + 1 <= buf_size); + else if (cell->wc == 0) + ctx->empty_count++; - mbstate_t ps = {0}; - size_t len = wcrtomb(&buf[idx], cell->wc, &ps); - assert(len >= 0); /* All wchars were valid multibyte strings to begin with */ - idx += len; - } + else { + /* Replace empty cells with spaces when followed by non-empty cell */ + assert(ctx->idx + ctx->empty_count <= ctx->size); + memset(&ctx->buf[ctx->idx], ' ', ctx->empty_count); + ctx->idx += ctx->empty_count; + ctx->empty_count = 0; - start_col = 0; + assert(ctx->idx + 1 <= ctx->size); + + mbstate_t ps = {0}; + size_t len = wcrtomb(&ctx->buf[ctx->idx], cell->wc, &ps); + assert(len >= 0); /* All wchars were valid multibyte strings to begin with */ + assert(ctx->idx + len <= ctx->size); + ctx->idx += len; } - if (idx == 0) { + ctx->last_row = row; + ctx->last_cell = cell; +} + +static char * +extract_selection(const struct terminal *term) +{ + const size_t max_cells = selection_cell_count(term); + const size_t buf_size = max_cells * 4 + 1; /* Multiply by 4 to handle multibyte chars */ + + struct extract ctx = { + .buf = malloc(buf_size), + .size = buf_size, + }; + + foreach_selected((struct terminal *)term, &extract_one, &ctx); + + if (ctx.idx == 0) { /* Selection of empty cells only */ - buf[idx] = '\0'; - return buf; + ctx.buf[ctx.idx] = '\0'; + return ctx.buf; } - assert(idx > 0); - assert(idx < buf_size); - if (buf[idx - 1] == '\n') - buf[idx - 1] = '\0'; + assert(ctx.idx > 0); + assert(ctx.idx < ctx.size); + if (ctx.buf[ctx.idx - 1] == '\n') + ctx.buf[ctx.idx - 1] = '\0'; else - buf[idx] = '\0'; + ctx.buf[ctx.idx] = '\0'; - return buf; + return ctx.buf; } void -- cgit v1.3 From e28cb989d84c14f1026c263419462bfdd3d58e2d Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 13:09:06 +0100 Subject: selection: simplify extraction by converting to UTF-8 at the end Instead of converting a cell at a time to UTF-8, copy the wide characters as is, and then convert everything at once at the end. --- selection.c | 46 +++++++++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 21 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index 1ecf6a7a..f81fcc85 100644 --- a/selection.c +++ b/selection.c @@ -188,7 +188,7 @@ selection_cell_count(const struct terminal *term) } struct extract { - char *buf; + wchar_t *buf; size_t size; size_t idx; size_t empty_count; @@ -207,7 +207,7 @@ extract_one(struct terminal *term, struct row *row, struct cell *cell, term->selection.kind == SELECTION_BLOCK)) { /* Last cell was the last column in the selection */ - ctx->buf[ctx->idx++] = '\n'; + ctx->buf[ctx->idx++] = L'\n'; ctx->empty_count = 0; } @@ -217,17 +217,12 @@ extract_one(struct terminal *term, struct row *row, struct cell *cell, else { /* Replace empty cells with spaces when followed by non-empty cell */ assert(ctx->idx + ctx->empty_count <= ctx->size); - memset(&ctx->buf[ctx->idx], ' ', ctx->empty_count); - ctx->idx += ctx->empty_count; + for (size_t i = 0; i < ctx->empty_count; i++) + ctx->buf[ctx->idx++] = L' '; ctx->empty_count = 0; assert(ctx->idx + 1 <= ctx->size); - - mbstate_t ps = {0}; - size_t len = wcrtomb(&ctx->buf[ctx->idx], cell->wc, &ps); - assert(len >= 0); /* All wchars were valid multibyte strings to begin with */ - assert(ctx->idx + len <= ctx->size); - ctx->idx += len; + ctx->buf[ctx->idx++] = cell->wc; } ctx->last_row = row; @@ -238,10 +233,10 @@ static char * extract_selection(const struct terminal *term) { const size_t max_cells = selection_cell_count(term); - const size_t buf_size = max_cells * 4 + 1; /* Multiply by 4 to handle multibyte chars */ + const size_t buf_size = max_cells + 1; struct extract ctx = { - .buf = malloc(buf_size), + .buf = malloc(buf_size * sizeof(wchar_t)), .size = buf_size, }; @@ -249,18 +244,27 @@ extract_selection(const struct terminal *term) if (ctx.idx == 0) { /* Selection of empty cells only */ - ctx.buf[ctx.idx] = '\0'; - return ctx.buf; + ctx.buf[ctx.idx] = L'\0'; + } else { + assert(ctx.idx > 0); + assert(ctx.idx < ctx.size); + if (ctx.buf[ctx.idx - 1] == L'\n') + ctx.buf[ctx.idx - 1] = L'\0'; + else + ctx.buf[ctx.idx] = L'\0'; } - assert(ctx.idx > 0); - assert(ctx.idx < ctx.size); - if (ctx.buf[ctx.idx - 1] == '\n') - ctx.buf[ctx.idx - 1] = '\0'; - else - ctx.buf[ctx.idx] = '\0'; + size_t len = wcstombs(NULL, ctx.buf, 0); + if (len == (size_t)-1) { + LOG_ERRNO("failed to convert selection to UTF-8"); + free(ctx.buf); + return NULL; + } - return ctx.buf; + char *ret = malloc(len + 1); + wcstombs(ret, ctx.buf, len + 1); + free(ctx.buf); + return ret; } void -- cgit v1.3 From 6ee86be1bf881f99533cc660123c6992f19f20f4 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 13:19:30 +0100 Subject: selection: fix bug where first column on all rows but the first was lost When extracting text from the selection, we lost the first column on all rows but the first. This is because the algorithm changed slightly when we moved to foreach_selection(); the end-of-line detection is now done on the first column of the new line, instead of the last column on the previous line. --- selection.c | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index f81fcc85..b241d375 100644 --- a/selection.c +++ b/selection.c @@ -211,19 +211,21 @@ extract_one(struct terminal *term, struct row *row, struct cell *cell, ctx->empty_count = 0; } - else if (cell->wc == 0) + if (cell->wc == 0) { ctx->empty_count++; + ctx->last_row = row; + ctx->last_cell = cell; + return; + } - else { - /* Replace empty cells with spaces when followed by non-empty cell */ - assert(ctx->idx + ctx->empty_count <= ctx->size); - for (size_t i = 0; i < ctx->empty_count; i++) - ctx->buf[ctx->idx++] = L' '; - ctx->empty_count = 0; + /* Replace empty cells with spaces when followed by non-empty cell */ + assert(ctx->idx + ctx->empty_count <= ctx->size); + for (size_t i = 0; i < ctx->empty_count; i++) + ctx->buf[ctx->idx++] = L' '; + ctx->empty_count = 0; - assert(ctx->idx + 1 <= ctx->size); - ctx->buf[ctx->idx++] = cell->wc; - } + assert(ctx->idx + 1 <= ctx->size); + ctx->buf[ctx->idx++] = cell->wc; ctx->last_row = row; ctx->last_cell = cell; -- cgit v1.3 From e6f04832949c97e829b21a2f5f71e268de00c7eb Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 13:53:30 +0100 Subject: selection: cell count now adds one extra column per row, for \n When we extract text, we may insert '\n' at the end of each line (or last column of selection, for block selections). These newlines doesn't occupy any physical cells, and thus we must **make** room for them in the extraction buffer. --- selection.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index b241d375..709334d4 100644 --- a/selection.c +++ b/selection.c @@ -160,8 +160,15 @@ selection_cell_count(const struct terminal *term) if (start->row == end->row) return end->col - start->col + 1; else { - size_t cells = term->cols - start->col; - cells += term->cols * (end->row - start->row - 1); + size_t cells = 0; + + /* First row; start of selection to end of row */ + cells += term->cols - start->col; + + /* Full rows; add one extra column for \n */ + cells += (term->cols + 1) * (end->row - start->row - 1); + + /* Final row; start of row to end of selection */ cells += end->col + 1; return cells; } @@ -177,7 +184,8 @@ selection_cell_count(const struct terminal *term) .col = max(start->col, end->col), }; - int cols = bottom_right.col - top_left.col + 1; + /* Add one extra column for \n */ + int cols = bottom_right.col - top_left.col + 1 + 1; int rows = bottom_right.row - top_left.row + 1; return rows * cols; } -- cgit v1.3 From 4c78b0203e89b20394ac0fa3a83973d923805ed6 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 13:56:52 +0100 Subject: selection: rename selection_cell_count -> min_bufsize_for_extraction --- selection.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index 709334d4..0df05647 100644 --- a/selection.c +++ b/selection.c @@ -136,7 +136,7 @@ foreach_selected( } static size_t -selection_cell_count(const struct terminal *term) +min_bufsize_for_extraction(const struct terminal *term) { const struct coord *start = &term->selection.start; const struct coord *end = &term->selection.end; @@ -242,7 +242,7 @@ extract_one(struct terminal *term, struct row *row, struct cell *cell, static char * extract_selection(const struct terminal *term) { - const size_t max_cells = selection_cell_count(term); + const size_t max_cells = min_bufsize_for_extraction(term); const size_t buf_size = max_cells + 1; struct extract ctx = { -- cgit v1.3 From a83c9e28137158fe0fb68a0e163e0305ca14ddeb Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sat, 4 Jan 2020 14:06:39 +0100 Subject: selection: min_bufsize_for_extraction: add one extra column for *all* rows --- selection.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) (limited to 'selection.c') diff --git a/selection.c b/selection.c index 0df05647..9a574169 100644 --- a/selection.c +++ b/selection.c @@ -162,14 +162,11 @@ min_bufsize_for_extraction(const struct terminal *term) else { size_t cells = 0; - /* First row; start of selection to end of row */ - cells += term->cols - start->col; + /* Add one extra column on each row, for \n */ - /* Full rows; add one extra column for \n */ + cells += term->cols - start->col + 1; cells += (term->cols + 1) * (end->row - start->row - 1); - - /* Final row; start of row to end of selection */ - cells += end->col + 1; + cells += end->col + 1 + 1; return cells; } @@ -184,7 +181,7 @@ min_bufsize_for_extraction(const struct terminal *term) .col = max(start->col, end->col), }; - /* Add one extra column for \n */ + /* Add one extra column on each row, for \n */ int cols = bottom_right.col - top_left.col + 1 + 1; int rows = bottom_right.row - top_left.row + 1; return rows * cols; -- cgit v1.3