mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/search.c
Daniel Eklöf 18b702b249
unicode-mode: move state from seat to term 
This fixes an issue where entering unicode-mode in one foot client,
also enabled unicode-mode on other foot clients. Both
visually (although glitchy), and in effect.

The reason the state was originally in the seat objects, was to fully
support multi-seat. That is, one seat/keyboard entering unicode-mode
should not affect other seats/keyboards.

The issue with this is that seat objects are Wayland global. Thus, in
server mode, all seat objects are shared between the foot clients.

There is a similarity with IME, which also keeps state in the
seat. There's one big difference, however, and that is IME has Wayland
native enter/leave events, that the compositor emits when windows are
focused/unfocused. These events allow us to reset IME state. For our
own Unicode mode, there is nothing similar.

This patch moves the Unicode state from seats, to the terminal
struct. This does mean that if one seat/keyboard enters Unicode mode,
then *all* seats/keyboards will affect the unicode state. This
potential downside is outweighed by the fact that different foot
clients no longer affect each other.

Closes #1717
2024-05-21 08:36:56 +02:00

1466 lines
42 KiB
C
Raw Blame History

#include "search.h"
#include <string.h>
#include <wayland-client.h>
#include <xkbcommon/xkbcommon-compose.h>
#define LOG_MODULE "search"
#define LOG_ENABLE_DBG 0
#include "log.h"
#include "char32.h"
#include "commands.h"
#include "config.h"
#include "extract.h"
#include "grid.h"
#include "input.h"
#include "key-binding.h"
#include "misc.h"
#include "quirks.h"
#include "render.h"
#include "selection.h"
#include "shm.h"
#include "unicode-mode.h"
#include "util.h"
#include "xmalloc.h"
/*
* Ensures a "new" viewport doesn't contain any unallocated rows.
*
* This is done by first checking if the *first* row is NULL. If so,
* we move the viewport *forward*, until the first row is non-NULL. At
* this point, the entire viewport should be allocated rows only.
*
* If the first row already was non-NULL, we instead check the *last*
* row, and if it is NULL, we move the viewport *backward* until the
* last row is non-NULL.
*/
static int
ensure_view_is_allocated(struct terminal *term, int new_view)
{
struct grid *grid = term->grid;
int view_end = (new_view + term->rows - 1) & (grid->num_rows - 1);
if (grid->rows[new_view] == NULL) {
while (grid->rows[new_view] == NULL)
new_view = (new_view + 1) & (grid->num_rows - 1);
}
else if (grid->rows[view_end] == NULL) {
while (grid->rows[view_end] == NULL) {
new_view--;
if (new_view < 0)
new_view += grid->num_rows;
view_end = (new_view + term->rows - 1) & (grid->num_rows - 1);
}
}
#if defined(_DEBUG)
for (size_t r = 0; r < term->rows; r++)
xassert(grid->rows[(new_view + r) & (grid->num_rows - 1)] != NULL);
#endif
return new_view;
}
static bool
search_ensure_size(struct terminal *term, size_t wanted_size)
{
while (wanted_size >= term->search.sz) {
size_t new_sz = term->search.sz == 0 ? 64 : term->search.sz * 2;
char32_t *new_buf = realloc(term->search.buf, new_sz * sizeof(term->search.buf[0]));
if (new_buf == NULL) {
LOG_ERRNO("failed to resize search buffer");
return false;
}
term->search.buf = new_buf;
term->search.sz = new_sz;
}
return true;
}
static bool
has_wrapped_around_left(const struct terminal *term, int abs_row_no)
{
int rebased_row = grid_row_abs_to_sb(term->grid, term->rows, abs_row_no);
return rebased_row == term->grid->num_rows - 1 || term->grid->rows[abs_row_no] == NULL;
}
static bool
has_wrapped_around_right(const struct terminal *term, int abs_row_no)
{
int rebased_row = grid_row_abs_to_sb(term->grid, term->rows, abs_row_no);
return rebased_row == 0;
}
static void
search_cancel_keep_selection(struct terminal *term)
{
struct wl_window *win = term->window;
wayl_win_subsurface_destroy(&win->search);
if (term->search.len > 0) {
free(term->search.last.buf);
term->search.last.buf = term->search.buf;
term->search.last.len = term->search.len;
} else
free(term->search.buf);
term->search.buf = NULL;
term->search.len = term->search.sz = 0;
term->search.cursor = 0;
term->search.match = (struct coord){-1, -1};
term->search.match_len = 0;
term->is_searching = false;
term->render.search_glyph_offset = 0;
/* Reset IME state */
if (term_ime_is_enabled(term)) {
term_ime_disable(term);
term_ime_enable(term);
}
term_xcursor_update(term);
render_refresh(term);
}
void
search_begin(struct terminal *term)
{
LOG_DBG("search: begin");
search_cancel_keep_selection(term);
selection_cancel(term);
/* Reset IME state */
if (term_ime_is_enabled(term)) {
term_ime_disable(term);
term_ime_enable(term);
}
/* On-demand instantiate wayland surface */
bool ret = wayl_win_subsurface_new(
term->window, &term->window->search, false);
xassert(ret);
const struct grid *grid = term->grid;
term->search.original_view = grid->view;
term->search.view_followed_offset = grid->view == grid->offset;
term->is_searching = true;
term->search.len = 0;
term->search.sz = 64;
term->search.buf = xmalloc(term->search.sz * sizeof(term->search.buf[0]));
term->search.buf[0] = U'\0';
term_xcursor_update(term);
render_refresh_search(term);
}
void
search_cancel(struct terminal *term)
{
if (!term->is_searching)
return;
search_cancel_keep_selection(term);
selection_cancel(term);
}
void
search_selection_cancelled(struct terminal *term)
{
term->search.match = (struct coord){-1, -1};
term->search.match_len = 0;
render_refresh_search(term);
}
static void
search_update_selection(struct terminal *term, const struct range *match)
{
struct grid *grid = term->grid;
int start_row = match->start.row;
int start_col = match->start.col;
int end_row = match->end.row;
int end_col = match->end.col;
xassert(start_row >= 0);
xassert(start_row < grid->num_rows);
bool move_viewport = true;
int view_end = (grid->view + term->rows - 1) & (grid->num_rows - 1);
if (view_end >= grid->view) {
/* Viewport does *not* wrap around */
if (start_row >= grid->view && end_row <= view_end)
move_viewport = false;
} else {
/* Viewport wraps */
if (start_row >= grid->view || end_row <= view_end)
move_viewport = false;
}
if (move_viewport) {
int rebased_new_view = grid_row_abs_to_sb(grid, term->rows, start_row);
rebased_new_view -= term->rows / 2;
rebased_new_view =
min(max(rebased_new_view, 0), grid->num_rows - term->rows);
const int old_view = grid->view;
int new_view = grid_row_sb_to_abs(grid, term->rows, rebased_new_view);
/* Scrollback may not be completely filled yet */
{
const int mask = grid->num_rows - 1;
while (grid->rows[new_view] == NULL)
new_view = (new_view + 1) & mask;
}
#if defined(_DEBUG)
/* Verify all to-be-visible rows have been allocated */
for (int r = 0; r < term->rows; r++)
xassert(grid->rows[(new_view + r) & (grid->num_rows - 1)] != NULL);
#endif
#if defined(_DEBUG)
{
int rel_start_row = grid_row_abs_to_sb(grid, term->rows, start_row);
int rel_view = grid_row_abs_to_sb(grid, term->rows, new_view);
xassert(rel_view <= rel_start_row);
xassert(rel_start_row < rel_view + term->rows);
}
#endif
/* Update view */
grid->view = new_view;
if (new_view != old_view)
term_damage_view(term);
}
if (start_row != term->search.match.row ||
start_col != term->search.match.col ||
/* Pointer leave events trigger selection_finalize() :/ */
!term->selection.ongoing)
{
int selection_row = start_row - grid->view + grid->num_rows;
selection_row &= grid->num_rows - 1;
selection_start(
term, start_col, selection_row, SELECTION_CHAR_WISE, false);
term->search.match.row = start_row;
term->search.match.col = start_col;
}
/* Update selection endpoint */
{
int selection_row = end_row - grid->view + grid->num_rows;
selection_row &= grid->num_rows - 1;
selection_update(term, end_col, selection_row);
}
}
static ssize_t
matches_cell(const struct terminal *term, const struct cell *cell, size_t search_ofs)
{
assert(search_ofs < term->search.len);
char32_t base = cell->wc;
const struct composed *composed = NULL;
if (base >= CELL_COMB_CHARS_LO && base <= CELL_COMB_CHARS_HI)
{
composed = composed_lookup(term->composed, base - CELL_COMB_CHARS_LO);
base = composed->chars[0];
}
if (composed == NULL && base == 0 && term->search.buf[search_ofs] == U' ')
return 1;
if (c32ncasecmp(&base, &term->search.buf[search_ofs], 1) != 0)
return -1;
if (composed != NULL) {
if (search_ofs + composed->count > term->search.len)
return -1;
for (size_t j = 1; j < composed->count; j++) {
if (composed->chars[j] != term->search.buf[search_ofs + j])
return -1;
}
}
return composed != NULL ? composed->count : 1;
}
static bool
find_next(struct terminal *term, enum search_direction direction,
struct coord abs_start, struct coord abs_end, struct range *match)
{
#define ROW_DEC(_r) ((_r) = ((_r) - 1 + grid->num_rows) & (grid->num_rows - 1))
#define ROW_INC(_r) ((_r) = ((_r) + 1) & (grid->num_rows - 1))
struct grid *grid = term->grid;
const bool backward = direction != SEARCH_FORWARD;
LOG_DBG("%s: start: %dx%d, end: %dx%d", backward ? "backward" : "forward",
abs_start.row, abs_start.col, abs_end.row, abs_end.col);
xassert(abs_start.row >= 0);
xassert(abs_start.row < grid->num_rows);
xassert(abs_start.col >= 0);
xassert(abs_start.col < term->cols);
xassert(abs_end.row >= 0);
xassert(abs_end.row < grid->num_rows);
xassert(abs_end.col >= 0);
xassert(abs_end.col < term->cols);
for (int match_start_row = abs_start.row, match_start_col = abs_start.col;
;
backward ? ROW_DEC(match_start_row) : ROW_INC(match_start_row)) {
const struct row *row = grid->rows[match_start_row];
if (row == NULL) {
if (match_start_row == abs_end.row)
break;
continue;
}
for (;
backward ? match_start_col >= 0 : match_start_col < term->cols;
backward ? match_start_col-- : match_start_col++)
{
if (matches_cell(term, &row->cells[match_start_col], 0) < 0) {
if (match_start_row == abs_end.row &&
match_start_col == abs_end.col)
{
break;
}
continue;
}
/*
* Got a match on the first letter. Now we'll see if the
* rest of the search buffer matches.
*/
LOG_DBG("search: initial match at row=%d, col=%d",
match_start_row, match_start_col);
int match_end_row = match_start_row;
int match_end_col = match_start_col;
const struct row *match_row = row;
size_t match_len = 0;
for (size_t i = 0; i < term->search.len;) {
if (match_end_col >= term->cols) {
ROW_INC(match_end_row);
match_end_col = 0;
match_row = grid->rows[match_end_row];
if (match_row == NULL)
break;
}
if (match_row->cells[match_end_col].wc >= CELL_SPACER) {
match_end_col++;
continue;
}
ssize_t additional_chars = matches_cell(
term, &match_row->cells[match_end_col], i);
if (additional_chars < 0)
break;
i += additional_chars;
match_len += additional_chars;
match_end_col++;
while (match_end_col < term->cols &&
match_row->cells[match_end_col].wc > CELL_SPACER)
{
match_end_col++;
}
}
if (match_len != term->search.len) {
/* Didn't match (completely) */
if (match_start_row == abs_end.row &&
match_start_col == abs_end.col)
{
break;
}
continue;
}
*match = (struct range){
.start = {match_start_col, match_start_row},
.end = {match_end_col - 1, match_end_row},
};
return true;
}
if (match_start_row == abs_end.row && match_start_col == abs_end.col)
break;
match_start_col = backward ? term->cols - 1 : 0;
}
return false;
}
static void
search_find_next(struct terminal *term, enum search_direction direction)
{
struct grid *grid = term->grid;
if (term->search.len == 0) {
term->search.match = (struct coord){-1, -1};
term->search.match_len = 0;
selection_cancel(term);
return;
}
struct coord start = term->search.match;
size_t len = term->search.match_len;
xassert((len == 0 && start.row == -1 && start.col == -1) ||
(len > 0 && start.row >= 0 && start.col >= 0));
if (len == 0) {
/* No previous match, start from the top, or bottom, of the scrollback */
switch (direction) {
case SEARCH_FORWARD:
start.row = grid_row_absolute_in_view(grid, 0);
start.col = 0;
break;
case SEARCH_BACKWARD:
case SEARCH_BACKWARD_SAME_POSITION:
start.row = grid_row_absolute_in_view(grid, term->rows - 1);
start.col = term->cols - 1;
break;
}
} else {
/* Continue from last match */
xassert(start.row >= 0);
xassert(start.col >= 0);
switch (direction) {
case SEARCH_BACKWARD_SAME_POSITION:
break;
case SEARCH_BACKWARD:
if (--start.col < 0) {
start.col = term->cols - 1;
start.row += grid->num_rows - 1;
start.row &= grid->num_rows - 1;
}
break;
case SEARCH_FORWARD:
if (++start.col >= term->cols) {
start.col = 0;
start.row++;
start.row &= grid->num_rows - 1;
}
break;
}
xassert(start.row >= 0);
xassert(start.row < grid->num_rows);
xassert(start.col >= 0);
xassert(start.col < term->cols);
}
LOG_DBG(
"update: %s: starting at row=%d col=%d "
"(offset = %d, view = %d)",
direction != SEARCH_FORWARD ? "backward" : "forward",
start.row, start.col,
grid->offset, grid->view);
struct coord end = start;
switch (direction) {
case SEARCH_FORWARD:
/* Search forward, until we reach the cell *before* current start */
if (--end.col < 0) {
end.col = term->cols - 1;
end.row += grid->num_rows - 1;
end.row &= grid->num_rows - 1;
}
break;
case SEARCH_BACKWARD:
case SEARCH_BACKWARD_SAME_POSITION:
/* Search backwards, until we reach the cell *after* current start */
if (++end.col >= term->cols) {
end.col = 0;
end.row++;
end.row &= grid->num_rows - 1;
}
break;
}
struct range match;
bool found = find_next(term, direction, start, end, &match);
if (found) {
LOG_DBG("primary match found at %dx%d",
match.start.row, match.start.col);
search_update_selection(term, &match);
term->search.match = match.start;
term->search.match_len = term->search.len;
} else {
LOG_DBG("no match");
term->search.match = (struct coord){-1, -1};
term->search.match_len = 0;
selection_cancel(term);
}
#undef ROW_DEC
}
struct search_match_iterator
search_matches_new_iter(struct terminal *term)
{
return (struct search_match_iterator){
.term = term,
.start = {0, 0},
};
}
struct range
search_matches_next(struct search_match_iterator *iter)
{
struct terminal *term = iter->term;
struct grid *grid = term->grid;
if (term->search.match_len == 0)
goto no_match;
if (iter->start.row >= term->rows)
goto no_match;
xassert(iter->start.row >= 0);
xassert(iter->start.row < term->rows);
xassert(iter->start.col >= 0);
xassert(iter->start.col < term->cols);
struct coord abs_start = iter->start;
abs_start.row = grid_row_absolute_in_view(grid, abs_start.row);
struct coord abs_end = {
term->cols - 1,
grid_row_absolute_in_view(grid, term->rows - 1)};
/* BUG: matches *starting* outside the view, but ending *inside*, aren't matched */
struct range match;
bool found = find_next(term, SEARCH_FORWARD, abs_start, abs_end, &match);
if (!found)
goto no_match;
LOG_DBG("match at (absolute coordinates) %dx%d-%dx%d",
match.start.row, match.start.col,
match.end.row, match.end.col);
/* Convert absolute row numbers back to view relative */
match.start.row = match.start.row - grid->view + grid->num_rows;
match.start.row &= grid->num_rows - 1;
match.end.row = match.end.row - grid->view + grid->num_rows;
match.end.row &= grid->num_rows - 1;
LOG_DBG("match at (view-local coordinates) %dx%d-%dx%d, view=%d",
match.start.row, match.start.col,
match.end.row, match.end.col, grid->view);
/* Assert match end comes *after* the match start */
xassert(match.end.row > match.start.row ||
(match.end.row == match.start.row &&
match.end.col >= match.start.col));
/* Assert the match starts at, or after, the iterator position */
xassert(match.start.row > iter->start.row ||
(match.start.row == iter->start.row &&
match.start.col >= iter->start.col));
/* Continue at next column, next time */
iter->start.row = match.start.row;
iter->start.col = match.start.col + 1;
if (iter->start.col >= term->cols) {
iter->start.col = 0;
iter->start.row++; /* Overflow is caught in next iteration */
}
xassert(iter->start.row >= 0);
xassert(iter->start.row <= term->rows);
xassert(iter->start.col >= 0);
xassert(iter->start.col < term->cols);
return match;
no_match:
iter->start.row = -1;
iter->start.col = -1;
return (struct range){{-1, -1}, {-1, -1}};
}
static void
add_wchars(struct terminal *term, char32_t *src, size_t count)
{
/* Strip non-printable characters */
for (size_t i = 0, j = 0, orig_count = count; i < orig_count; i++) {
if (isc32print(src[i]))
src[j++] = src[i];
else
count--;
}
if (!search_ensure_size(term, term->search.len + count))
return;
xassert(term->search.len + count < term->search.sz);
memmove(&term->search.buf[term->search.cursor + count],
&term->search.buf[term->search.cursor],
(term->search.len - term->search.cursor) * sizeof(char32_t));
memcpy(&term->search.buf[term->search.cursor], src, count * sizeof(char32_t));
term->search.len += count;
term->search.cursor += count;
term->search.buf[term->search.len] = U'\0';
}
void
search_add_chars(struct terminal *term, const char *src, size_t count)
{
size_t chars = mbsntoc32(NULL, src, count, 0);
if (chars == (size_t)-1) {
LOG_ERRNO("failed to convert %.*s to Unicode", (int)count, src);
return;
}
char32_t c32s[chars + 1];
mbsntoc32(c32s, src, count, chars);
add_wchars(term, c32s, chars);
}
enum extend_direction {SEARCH_EXTEND_LEFT, SEARCH_EXTEND_RIGHT};
static bool
coord_advance_left(const struct terminal *term, struct coord *pos,
const struct row **row)
{
const struct grid *grid = term->grid;
struct coord new_pos = *pos;
if (--new_pos.col < 0) {
new_pos.row = (new_pos.row - 1 + grid->num_rows) & (grid->num_rows - 1);
new_pos.col = term->cols - 1;
if (has_wrapped_around_left(term, new_pos.row))
return false;
if (row != NULL)
*row = grid->rows[new_pos.row];
}
*pos = new_pos;
return true;
}
static bool
coord_advance_right(const struct terminal *term, struct coord *pos,
const struct row **row)
{
const struct grid *grid = term->grid;
struct coord new_pos = *pos;
if (++new_pos.col >= term->cols) {
new_pos.row = (new_pos.row + 1) & (grid->num_rows - 1);
new_pos.col = 0;
if (has_wrapped_around_right(term, new_pos.row))
return false;
if (row != NULL)
*row = grid->rows[new_pos.row];
}
*pos = new_pos;
return true;
}
static bool
search_extend_find_char(const struct terminal *term, struct coord *target,
enum extend_direction direction)
{
if (term->search.match_len == 0)
return false;
struct coord pos = direction == SEARCH_EXTEND_LEFT
? selection_get_start(term) : selection_get_end(term);
xassert(pos.row >= 0);
xassert(pos.row < term->grid->num_rows);
*target = pos;
const struct row *row = term->grid->rows[pos.row];
while (true) {
switch (direction) {
case SEARCH_EXTEND_LEFT:
if (!coord_advance_left(term, &pos, &row))
return false;
break;
case SEARCH_EXTEND_RIGHT:
if (!coord_advance_right(term, &pos, &row))
return false;
break;
}
const char32_t wc = row->cells[pos.col].wc;
if (wc >= CELL_SPACER || wc == U'\0')
continue;
*target = pos;
return true;
}
}
static bool
search_extend_find_char_left(const struct terminal *term, struct coord *target)
{
return search_extend_find_char(term, target, SEARCH_EXTEND_LEFT);
}
static bool
search_extend_find_char_right(const struct terminal *term, struct coord *target)
{
return search_extend_find_char(term, target, SEARCH_EXTEND_RIGHT);
}
static bool
search_extend_find_word(const struct terminal *term, bool spaces_only,
struct coord *target, enum extend_direction direction)
{
if (term->search.match_len == 0)
return false;
struct grid *grid = term->grid;
struct coord pos = direction == SEARCH_EXTEND_LEFT
? selection_get_start(term)
: selection_get_end(term);
xassert(pos.row >= 0);
xassert(pos.row < grid->num_rows);
*target = pos;
/* First character to consider is the *next* character */
switch (direction) {
case SEARCH_EXTEND_LEFT:
if (!coord_advance_left(term, &pos, NULL))
return false;
break;
case SEARCH_EXTEND_RIGHT:
if (!coord_advance_right(term, &pos, NULL))
return false;
break;
}
xassert(pos.row >= 0);
xassert(pos.row < grid->num_rows);
xassert(grid->rows[pos.row] != NULL);
/* Find next word boundary */
switch (direction) {
case SEARCH_EXTEND_LEFT:
selection_find_word_boundary_left(term, &pos, spaces_only);
break;
case SEARCH_EXTEND_RIGHT:
selection_find_word_boundary_right(term, &pos, spaces_only, false);
break;
}
*target = pos;
return true;
}
static bool
search_extend_find_word_left(const struct terminal *term, bool spaces_only,
struct coord *target)
{
return search_extend_find_word(term, spaces_only, target, SEARCH_EXTEND_LEFT);
}
static bool
search_extend_find_word_right(const struct terminal *term, bool spaces_only,
struct coord *target)
{
return search_extend_find_word(term, spaces_only, target, SEARCH_EXTEND_RIGHT);
}
static bool
search_extend_find_line(const struct terminal *term, struct coord *target,
enum extend_direction direction)
{
if (term->search.match_len == 0)
return false;
struct coord pos = direction == SEARCH_EXTEND_LEFT
? selection_get_start(term) : selection_get_end(term);
xassert(pos.row >= 0);
xassert(pos.row < term->grid->num_rows);
*target = pos;
const struct grid *grid = term->grid;
switch (direction) {
case SEARCH_EXTEND_LEFT:
pos.row = (pos.row - 1 + grid->num_rows) & (grid->num_rows - 1);
if (has_wrapped_around_left(term, pos.row))
return false;
break;
case SEARCH_EXTEND_RIGHT:
pos.row = (pos.row + 1) & (grid->num_rows - 1);
if (has_wrapped_around_right(term, pos.row))
return false;
break;
}
*target = pos;
return true;
}
static bool
search_extend_find_line_up(const struct terminal *term, struct coord *target)
{
return search_extend_find_line(term, target, SEARCH_EXTEND_LEFT);
}
static bool
search_extend_find_line_down(const struct terminal *term, struct coord *target)
{
return search_extend_find_line(term, target, SEARCH_EXTEND_RIGHT);
}
static void
search_extend_left(struct terminal *term, const struct coord *target)
{
if (term->search.match_len == 0)
return;
const struct coord last_coord = selection_get_start(term);
struct coord pos = *target;
const struct row *row = term->grid->rows[pos.row];
const bool move_cursor = term->search.cursor != 0;
struct extraction_context *ctx = extract_begin(SELECTION_NONE, false);
if (ctx == NULL)
return;
while (pos.col != last_coord.col || pos.row != last_coord.row) {
if (!extract_one(term, row, &row->cells[pos.col], pos.col, ctx))
break;
if (!coord_advance_right(term, &pos, &row))
break;
}
char32_t *new_text;
size_t new_len;
if (!extract_finish_wide(ctx, &new_text, &new_len))
return;
if (!search_ensure_size(term, term->search.len + new_len))
return;
memmove(&term->search.buf[new_len], &term->search.buf[0],
term->search.len * sizeof(term->search.buf[0]));
size_t actually_copied = 0;
for (size_t i = 0; i < new_len; i++) {
if (new_text[i] == U'\n') {
/* extract() adds newlines, which we never match against */
continue;
}
term->search.buf[actually_copied++] = new_text[i];
term->search.len++;
}
xassert(actually_copied <= new_len);
if (actually_copied < new_len) {
memmove(
&term->search.buf[actually_copied], &term->search.buf[new_len],
(term->search.len - actually_copied) * sizeof(term->search.buf[0]));
}
term->search.buf[term->search.len] = U'\0';
free(new_text);
if (move_cursor)
term->search.cursor += actually_copied;
struct range match = {.start = *target, .end = selection_get_end(term)};
search_update_selection(term, &match);
term->search.match_len = term->search.len;
}
static void
search_extend_right(struct terminal *term, const struct coord *target)
{
if (term->search.match_len == 0)
return;
struct coord pos = selection_get_end(term);
const struct row *row = term->grid->rows[pos.row];
const bool move_cursor = term->search.cursor == term->search.len;
struct extraction_context *ctx = extract_begin(SELECTION_NONE, false);
if (ctx == NULL)
return;
do {
if (!coord_advance_right(term, &pos, &row))
break;
if (!extract_one(term, row, &row->cells[pos.col], pos.col, ctx))
break;
} while (pos.col != target->col || pos.row != target->row);
char32_t *new_text;
size_t new_len;
if (!extract_finish_wide(ctx, &new_text, &new_len))
return;
if (!search_ensure_size(term, term->search.len + new_len))
return;
for (size_t i = 0; i < new_len; i++) {
if (new_text[i] == U'\n') {
/* extract() adds newlines, which we never match against */
continue;
}
term->search.buf[term->search.len++] = new_text[i];
}
term->search.buf[term->search.len] = U'\0';
free(new_text);
if (move_cursor)
term->search.cursor = term->search.len;
struct range match = {.start = term->search.match, .end = *target};
search_update_selection(term, &match);
term->search.match_len = term->search.len;
}
static size_t
distance_next_word(const struct terminal *term)
{
size_t cursor = term->search.cursor;
/* First eat non-whitespace. This is the word we're skipping past */
while (cursor < term->search.len) {
if (isc32space(term->search.buf[cursor++]))
break;
}
xassert(cursor == term->search.len || isc32space(term->search.buf[cursor - 1]));
/* Now skip past whitespace, so that we end up at the beginning of
* the next word */
while (cursor < term->search.len) {
if (!isc32space(term->search.buf[cursor++]))
break;
}
xassert(cursor == term->search.len || !isc32space(term->search.buf[cursor - 1]));
if (cursor < term->search.len && !isc32space(term->search.buf[cursor]))
cursor--;
return cursor - term->search.cursor;
}
static size_t
distance_prev_word(const struct terminal *term)
{
int cursor = term->search.cursor;
/* First, eat whitespace prefix */
while (cursor > 0) {
if (!isc32space(term->search.buf[--cursor]))
break;
}
xassert(cursor == 0 || !isc32space(term->search.buf[cursor]));
/* Now eat non-whitespace. This is the word we're skipping past */
while (cursor > 0) {
if (isc32space(term->search.buf[--cursor]))
break;
}
xassert(cursor == 0 || isc32space(term->search.buf[cursor]));
if (cursor > 0 && isc32space(term->search.buf[cursor]))
cursor++;
return term->search.cursor - cursor;
}
static void
from_clipboard_cb(char *text, size_t size, void *user)
{
struct terminal *term = user;
search_add_chars(term, text, size);
}
static void
from_clipboard_done(void *user)
{
struct terminal *term = user;
LOG_DBG("search: buffer: %ls", (const wchar_t *)term->search.buf);
search_find_next(term, SEARCH_BACKWARD_SAME_POSITION);
render_refresh_search(term);
}
static bool
execute_binding(struct seat *seat, struct terminal *term,
const struct key_binding *binding, uint32_t serial,
bool *update_search_result, enum search_direction *direction,
bool *redraw)
{
*update_search_result = *redraw = false;
const enum bind_action_search action = binding->action;
struct grid *grid = term->grid;
switch (action) {
case BIND_ACTION_SEARCH_NONE:
return false;
case BIND_ACTION_SEARCH_SCROLLBACK_UP_PAGE:
if (term->grid == &term->normal) {
cmd_scrollback_up(term, term->rows);
return true;
}
return false;
case BIND_ACTION_SEARCH_SCROLLBACK_UP_HALF_PAGE:
if (term->grid == &term->normal) {
cmd_scrollback_up(term, max(term->rows / 2, 1));
return true;
}
break;
case BIND_ACTION_SEARCH_SCROLLBACK_UP_LINE:
if (term->grid == &term->normal) {
cmd_scrollback_up(term, 1);
return true;
}
break;
case BIND_ACTION_SEARCH_SCROLLBACK_DOWN_PAGE:
if (term->grid == &term->normal) {
cmd_scrollback_down(term, term->rows);
return true;
}
return false;
case BIND_ACTION_SEARCH_SCROLLBACK_DOWN_HALF_PAGE:
if (term->grid == &term->normal) {
cmd_scrollback_down(term, max(term->rows / 2, 1));
return true;
}
break;
case BIND_ACTION_SEARCH_SCROLLBACK_DOWN_LINE:
if (term->grid == &term->normal) {
cmd_scrollback_down(term, 1);
return true;
}
break;
case BIND_ACTION_SEARCH_SCROLLBACK_HOME:
if (term->grid == &term->normal) {
cmd_scrollback_up(term, term->grid->num_rows);
return true;
}
break;
case BIND_ACTION_SEARCH_SCROLLBACK_END:
if (term->grid == &term->normal) {
cmd_scrollback_down(term, term->grid->num_rows);
return true;
}
break;
case BIND_ACTION_SEARCH_CANCEL:
if (term->search.view_followed_offset)
grid->view = grid->offset;
else {
grid->view = ensure_view_is_allocated(
term, term->search.original_view);
}
term_damage_view(term);
search_cancel(term);
return true;
case BIND_ACTION_SEARCH_COMMIT:
selection_finalize(seat, term, serial);
search_cancel_keep_selection(term);
return true;
case BIND_ACTION_SEARCH_FIND_PREV:
if (term->search.last.buf != NULL && term->search.len == 0) {
add_wchars(term, term->search.last.buf, term->search.last.len);
free(term->search.last.buf);
term->search.last.buf = NULL;
term->search.last.len = 0;
}
*direction = SEARCH_BACKWARD;
*update_search_result = *redraw = true;
return true;
case BIND_ACTION_SEARCH_FIND_NEXT:
if (term->search.last.buf != NULL && term->search.len == 0) {
add_wchars(term, term->search.last.buf, term->search.last.len);
free(term->search.last.buf);
term->search.last.buf = NULL;
term->search.last.len = 0;
}
*direction = SEARCH_FORWARD;
*update_search_result = *redraw = true;
return true;
case BIND_ACTION_SEARCH_EDIT_LEFT:
if (term->search.cursor > 0) {
term->search.cursor--;
*redraw = true;
}
return true;
case BIND_ACTION_SEARCH_EDIT_LEFT_WORD: {
size_t diff = distance_prev_word(term);
term->search.cursor -= diff;
xassert(term->search.cursor <= term->search.len);
if (diff > 0)
*redraw = true;
return true;
}
case BIND_ACTION_SEARCH_EDIT_RIGHT:
if (term->search.cursor < term->search.len) {
term->search.cursor++;
*redraw = true;
}
return true;
case BIND_ACTION_SEARCH_EDIT_RIGHT_WORD: {
size_t diff = distance_next_word(term);
term->search.cursor += diff;
xassert(term->search.cursor <= term->search.len);
if (diff > 0)
*redraw = true;
return true;
}
case BIND_ACTION_SEARCH_EDIT_HOME:
if (term->search.cursor != 0) {
term->search.cursor = 0;
*redraw = true;
}
return true;
case BIND_ACTION_SEARCH_EDIT_END:
if (term->search.cursor != term->search.len) {
term->search.cursor = term->search.len;
*redraw = true;
}
return true;
case BIND_ACTION_SEARCH_DELETE_PREV:
if (term->search.cursor > 0) {
memmove(
&term->search.buf[term->search.cursor - 1],
&term->search.buf[term->search.cursor],
(term->search.len - term->search.cursor) * sizeof(char32_t));
term->search.cursor--;
term->search.buf[--term->search.len] = U'\0';
*update_search_result = *redraw = true;
}
return true;
case BIND_ACTION_SEARCH_DELETE_PREV_WORD: {
size_t diff = distance_prev_word(term);
size_t old_cursor = term->search.cursor;
size_t new_cursor = old_cursor - diff;
if (diff > 0) {
memmove(&term->search.buf[new_cursor],
&term->search.buf[old_cursor],
(term->search.len - old_cursor) * sizeof(char32_t));
term->search.len -= diff;
term->search.cursor = new_cursor;
*update_search_result = *redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_DELETE_NEXT:
if (term->search.cursor < term->search.len) {
memmove(
&term->search.buf[term->search.cursor],
&term->search.buf[term->search.cursor + 1],
(term->search.len - term->search.cursor - 1) * sizeof(char32_t));
term->search.buf[--term->search.len] = U'\0';
*update_search_result = *redraw = true;
}
return true;
case BIND_ACTION_SEARCH_DELETE_NEXT_WORD: {
size_t diff = distance_next_word(term);
size_t cursor = term->search.cursor;
if (diff > 0) {
memmove(&term->search.buf[cursor],
&term->search.buf[cursor + diff],
(term->search.len - (cursor + diff)) * sizeof(char32_t));
term->search.len -= diff;
*update_search_result = *redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_CHAR: {
struct coord target;
if (search_extend_find_char_right(term, &target)) {
search_extend_right(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_WORD: {
struct coord target;
if (search_extend_find_word_right(term, false, &target)) {
search_extend_right(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_WORD_WS: {
struct coord target;
if (search_extend_find_word_right(term, true, &target)) {
search_extend_right(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_LINE_DOWN: {
struct coord target;
if (search_extend_find_line_down(term, &target)) {
search_extend_right(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_BACKWARD_CHAR: {
struct coord target;
if (search_extend_find_char_left(term, &target)) {
search_extend_left(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_BACKWARD_WORD: {
struct coord target;
if (search_extend_find_word_left(term, false, &target)) {
search_extend_left(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_BACKWARD_WORD_WS: {
struct coord target;
if (search_extend_find_word_left(term, true, &target)) {
search_extend_left(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_EXTEND_LINE_UP: {
struct coord target;
if (search_extend_find_line_up(term, &target)) {
search_extend_left(term, &target);
*update_search_result = false;
*redraw = true;
}
return true;
}
case BIND_ACTION_SEARCH_CLIPBOARD_PASTE:
text_from_clipboard(
seat, term, &from_clipboard_cb, &from_clipboard_done, term);
*update_search_result = *redraw = true;
return true;
case BIND_ACTION_SEARCH_PRIMARY_PASTE:
text_from_primary(
seat, term, &from_clipboard_cb, &from_clipboard_done, term);
*update_search_result = *redraw = true;
return true;
case BIND_ACTION_SEARCH_UNICODE_INPUT:
unicode_mode_activate(term);
return true;
case BIND_ACTION_SEARCH_COUNT:
BUG("Invalid action type");
return true;
}
BUG("Unhandled action type");
return false;
}
void
search_input(struct seat *seat, struct terminal *term,
const struct key_binding_set *bindings, uint32_t key,
xkb_keysym_t sym, xkb_mod_mask_t mods, xkb_mod_mask_t consumed,
const xkb_keysym_t *raw_syms, size_t raw_count,
uint32_t serial)
{
LOG_DBG("search: input: sym=%d/0x%x, mods=0x%08x, consumed=0x%08x",
sym, sym, mods, consumed);
enum xkb_compose_status compose_status = seat->kbd.xkb_compose_state != NULL
? xkb_compose_state_get_status(seat->kbd.xkb_compose_state)
: XKB_COMPOSE_NOTHING;
enum search_direction search_direction = SEARCH_BACKWARD_SAME_POSITION;
bool update_search_result = false;
bool redraw = false;
/* Key bindings */
tll_foreach(bindings->search, it) {
const struct key_binding *bind = &it->item;
/* Match translated symbol */
if (bind->k.sym == sym &&
bind->mods == (mods & ~consumed)) {
if (execute_binding(seat, term, bind, serial,
&update_search_result, &search_direction,
&redraw))
{
goto update_search;
}
return;
}
if (bind->mods != mods)
continue;
/* Match untranslated symbols */
for (size_t i = 0; i < raw_count; i++) {
if (bind->k.sym == raw_syms[i]) {
if (execute_binding(seat, term, bind, serial,
&update_search_result, &search_direction,
&redraw))
{
goto update_search;
}
return;
}
}
/* Match raw key code */
tll_foreach(bind->k.key_codes, code) {
if (code->item == key) {
if (execute_binding(seat, term, bind, serial,
&update_search_result, &search_direction,
&redraw))
{
goto update_search;
}
return;
}
}
}
uint8_t buf[64] = {0};
int count = 0;
if (compose_status == XKB_COMPOSE_COMPOSED) {
count = xkb_compose_state_get_utf8(
seat->kbd.xkb_compose_state, (char *)buf, sizeof(buf));
xkb_compose_state_reset(seat->kbd.xkb_compose_state);
} else if (compose_status == XKB_COMPOSE_CANCELLED) {
count = 0;
} else {
count = xkb_state_key_get_utf8(
seat->kbd.xkb_state, key, (char *)buf, sizeof(buf));
}
update_search_result = redraw = count > 0;
search_direction = SEARCH_BACKWARD_SAME_POSITION;
if (count == 0)
return;
search_add_chars(term, (const char *)buf, count);
update_search:
LOG_DBG("search: buffer: %ls", (const wchar_t *)term->search.buf);
if (update_search_result)
search_find_next(term, search_direction);
if (redraw)
render_refresh_search(term);
}
Reference in a new issue View git blame Copy permalink