?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tweak previous - find end of style correctly.
[tmux-openbsd.git] / window-copy.c
blobb955d222e065730db256de742479c2b0574e4c57
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/types.h>
20
21 #include <ctype.h>
22 #include <regex.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <time.h>
26
27 #include "tmux.h"
28
29 struct window_copy_mode_data;
30
31 static const char *window_copy_key_table(struct window_mode_entry *);
32 static void window_copy_command(struct window_mode_entry *, struct client *,
33 struct session *, struct winlink *, struct args *,
34 struct mouse_event *);
35 static struct screen *window_copy_init(struct window_mode_entry *,
36 struct cmd_find_state *, struct args *);
37 static struct screen *window_copy_view_init(struct window_mode_entry *,
38 struct cmd_find_state *, struct args *);
39 static void window_copy_free(struct window_mode_entry *);
40 static void window_copy_resize(struct window_mode_entry *, u_int, u_int);
41 static void window_copy_formats(struct window_mode_entry *,
42 struct format_tree *);
43 static void window_copy_pageup1(struct window_mode_entry *, int);
44 static int window_copy_pagedown(struct window_mode_entry *, int, int);
45 static void window_copy_next_paragraph(struct window_mode_entry *);
46 static void window_copy_previous_paragraph(struct window_mode_entry *);
47 static void window_copy_redraw_selection(struct window_mode_entry *, u_int);
48 static void window_copy_redraw_lines(struct window_mode_entry *, u_int,
49 u_int);
50 static void window_copy_redraw_screen(struct window_mode_entry *);
51 static void window_copy_write_line(struct window_mode_entry *,
52 struct screen_write_ctx *, u_int);
53 static void window_copy_write_lines(struct window_mode_entry *,
54 struct screen_write_ctx *, u_int, u_int);
55 static char *window_copy_match_at_cursor(struct window_copy_mode_data *);
56 static void window_copy_scroll_to(struct window_mode_entry *, u_int, u_int,
57 int);
58 static int window_copy_search_compare(struct grid *, u_int, u_int,
59 struct grid *, u_int, int);
60 static int window_copy_search_lr(struct grid *, struct grid *, u_int *,
61 u_int, u_int, u_int, int);
62 static int window_copy_search_rl(struct grid *, struct grid *, u_int *,
63 u_int, u_int, u_int, int);
64 static int window_copy_last_regex(struct grid *, u_int, u_int, u_int,
65 u_int, u_int *, u_int *, const char *, const regex_t *,
66 int);
67 static int window_copy_search_mark_at(struct window_copy_mode_data *,
68 u_int, u_int, u_int *);
69 static char *window_copy_stringify(struct grid *, u_int, u_int, u_int,
70 char *, u_int *);
71 static void window_copy_cstrtocellpos(struct grid *, u_int, u_int *,
72 u_int *, const char *);
73 static int window_copy_search_marks(struct window_mode_entry *,
74 struct screen *, int, int);
75 static void window_copy_clear_marks(struct window_mode_entry *);
76 static int window_copy_is_lowercase(const char *);
77 static void window_copy_search_back_overlap(struct grid *, regex_t *,
78 u_int *, u_int *, u_int *, u_int);
79 static int window_copy_search_jump(struct window_mode_entry *,
80 struct grid *, struct grid *, u_int, u_int, u_int, int, int,
81 int, int);
82 static int window_copy_search(struct window_mode_entry *, int, int);
83 static int window_copy_search_up(struct window_mode_entry *, int);
84 static int window_copy_search_down(struct window_mode_entry *, int);
85 static void window_copy_goto_line(struct window_mode_entry *, const char *);
86 static void window_copy_update_cursor(struct window_mode_entry *, u_int,
87 u_int);
88 static void window_copy_start_selection(struct window_mode_entry *);
89 static int window_copy_adjust_selection(struct window_mode_entry *,
90 u_int *, u_int *);
91 static int window_copy_set_selection(struct window_mode_entry *, int, int);
92 static int window_copy_update_selection(struct window_mode_entry *, int,
93 int);
94 static void window_copy_synchronize_cursor(struct window_mode_entry *, int);
95 static void *window_copy_get_selection(struct window_mode_entry *, size_t *);
96 static void window_copy_copy_buffer(struct window_mode_entry *,
97 const char *, void *, size_t);
98 static void window_copy_pipe(struct window_mode_entry *,
99 struct session *, const char *);
100 static void window_copy_copy_pipe(struct window_mode_entry *,
101 struct session *, const char *, const char *);
102 static void window_copy_copy_selection(struct window_mode_entry *,
103 const char *);
104 static void window_copy_append_selection(struct window_mode_entry *);
105 static void window_copy_clear_selection(struct window_mode_entry *);
106 static void window_copy_copy_line(struct window_mode_entry *, char **,
107 size_t *, u_int, u_int, u_int);
108 static int window_copy_in_set(struct window_mode_entry *, u_int, u_int,
109 const char *);
110 static u_int window_copy_find_length(struct window_mode_entry *, u_int);
111 static void window_copy_cursor_start_of_line(struct window_mode_entry *);
112 static void window_copy_cursor_back_to_indentation(
113 struct window_mode_entry *);
114 static void window_copy_cursor_end_of_line(struct window_mode_entry *);
115 static void window_copy_other_end(struct window_mode_entry *);
116 static void window_copy_cursor_left(struct window_mode_entry *);
117 static void window_copy_cursor_right(struct window_mode_entry *, int);
118 static void window_copy_cursor_up(struct window_mode_entry *, int);
119 static void window_copy_cursor_down(struct window_mode_entry *, int);
120 static void window_copy_cursor_jump(struct window_mode_entry *);
121 static void window_copy_cursor_jump_back(struct window_mode_entry *);
122 static void window_copy_cursor_jump_to(struct window_mode_entry *);
123 static void window_copy_cursor_jump_to_back(struct window_mode_entry *);
124 static void window_copy_cursor_next_word(struct window_mode_entry *,
125 const char *);
126 static void window_copy_cursor_next_word_end_pos(struct window_mode_entry *,
127 const char *, u_int *, u_int *);
128 static void window_copy_cursor_next_word_end(struct window_mode_entry *,
129 const char *, int);
130 static void window_copy_cursor_previous_word_pos(struct window_mode_entry *,
131 const char *, u_int *, u_int *);
132 static void window_copy_cursor_previous_word(struct window_mode_entry *,
133 const char *, int);
134 static void window_copy_scroll_up(struct window_mode_entry *, u_int);
135 static void window_copy_scroll_down(struct window_mode_entry *, u_int);
136 static void window_copy_rectangle_set(struct window_mode_entry *, int);
137 static void window_copy_move_mouse(struct mouse_event *);
138 static void window_copy_drag_update(struct client *, struct mouse_event *);
139 static void window_copy_drag_release(struct client *, struct mouse_event *);
140 static void window_copy_jump_to_mark(struct window_mode_entry *);
141 static void window_copy_acquire_cursor_up(struct window_mode_entry *,
142 u_int, u_int, u_int, u_int, u_int);
143 static void window_copy_acquire_cursor_down(struct window_mode_entry *,
144 u_int, u_int, u_int, u_int, u_int, u_int, int);
145
146 const struct window_mode window_copy_mode = {
147 .name = "copy-mode",
148
149 .init = window_copy_init,
150 .free = window_copy_free,
151 .resize = window_copy_resize,
152 .key_table = window_copy_key_table,
153 .command = window_copy_command,
154 .formats = window_copy_formats,
155 };
156
157 const struct window_mode window_view_mode = {
158 .name = "view-mode",
159
160 .init = window_copy_view_init,
161 .free = window_copy_free,
162 .resize = window_copy_resize,
163 .key_table = window_copy_key_table,
164 .command = window_copy_command,
165 .formats = window_copy_formats,
166 };
167
168 enum {
169 WINDOW_COPY_OFF,
170 WINDOW_COPY_SEARCHUP,
171 WINDOW_COPY_SEARCHDOWN,
172 WINDOW_COPY_JUMPFORWARD,
173 WINDOW_COPY_JUMPBACKWARD,
174 WINDOW_COPY_JUMPTOFORWARD,
175 WINDOW_COPY_JUMPTOBACKWARD,
176 };
177
178 enum {
179 WINDOW_COPY_REL_POS_ABOVE,
180 WINDOW_COPY_REL_POS_ON_SCREEN,
181 WINDOW_COPY_REL_POS_BELOW,
182 };
183
184 enum window_copy_cmd_action {
185 WINDOW_COPY_CMD_NOTHING,
186 WINDOW_COPY_CMD_REDRAW,
187 WINDOW_COPY_CMD_CANCEL,
188 };
189
190 enum window_copy_cmd_clear {
191 WINDOW_COPY_CMD_CLEAR_ALWAYS,
192 WINDOW_COPY_CMD_CLEAR_NEVER,
193 WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
194 };
195
196 struct window_copy_cmd_state {
197 struct window_mode_entry *wme;
198 struct args *args;
199 struct mouse_event *m;
200
201 struct client *c;
202 struct session *s;
203 struct winlink *wl;
204 };
205
206 /*
207 * Copy mode's visible screen (the "screen" field) is filled from one of two
208 * sources: the original contents of the pane (used when we actually enter via
209 * the "copy-mode" command, to copy the contents of the current pane), or else
210 * a series of lines containing the output from an output-writing tmux command
211 * (such as any of the "show-*" or "list-*" commands).
212 *
213 * In either case, the full content of the copy-mode grid is pointed at by the
214 * "backing" field, and is copied into "screen" as needed (that is, when
215 * scrolling occurs). When copy-mode is backed by a pane, backing points
216 * directly at that pane's screen structure (&wp->base); when backed by a list
217 * of output-lines from a command, it points at a newly-allocated screen
218 * structure (which is deallocated when the mode ends).
219 */
220 struct window_copy_mode_data {
221 struct screen screen;
222
223 struct screen *backing;
224 int backing_written; /* backing display started */
225 struct screen *writing;
226 struct input_ctx *ictx;
227
228 int viewmode; /* view mode entered */
229
230 u_int oy; /* number of lines scrolled up */
231
232 u_int selx; /* beginning of selection */
233 u_int sely;
234
235 u_int endselx; /* end of selection */
236 u_int endsely;
237
238 enum {
239 CURSORDRAG_NONE, /* selection is independent of cursor */
240 CURSORDRAG_ENDSEL, /* end is synchronized with cursor */
241 CURSORDRAG_SEL, /* start is synchronized with cursor */
242 } cursordrag;
243
244 int modekeys;
245 enum {
246 LINE_SEL_NONE,
247 LINE_SEL_LEFT_RIGHT,
248 LINE_SEL_RIGHT_LEFT,
249 } lineflag; /* line selection mode */
250 int rectflag; /* in rectangle copy mode? */
251 int scroll_exit; /* exit on scroll to end? */
252 int hide_position; /* hide position marker */
253
254 enum {
255 SEL_CHAR, /* select one char at a time */
256 SEL_WORD, /* select one word at a time */
257 SEL_LINE, /* select one line at a time */
258 } selflag;
259
260 const char *separators; /* word separators */
261
262 u_int dx; /* drag start position */
263 u_int dy;
264
265 u_int selrx; /* selection reset positions */
266 u_int selry;
267 u_int endselrx;
268 u_int endselry;
269
270 u_int cx;
271 u_int cy;
272
273 u_int lastcx; /* position in last line w/ content */
274 u_int lastsx; /* size of last line w/ content */
275
276 u_int mx; /* mark position */
277 u_int my;
278 int showmark;
279
280 int searchtype;
281 int searchdirection;
282 int searchregex;
283 char *searchstr;
284 u_char *searchmark;
285 int searchcount;
286 int searchmore;
287 int searchall;
288 int searchx;
289 int searchy;
290 int searcho;
291 u_char searchgen;
292
293 int timeout; /* search has timed out */
294 #define WINDOW_COPY_SEARCH_TIMEOUT 10000
295 #define WINDOW_COPY_SEARCH_ALL_TIMEOUT 200
296
297 int jumptype;
298 struct utf8_data *jumpchar;
299
300 struct event dragtimer;
301 #define WINDOW_COPY_DRAG_REPEAT_TIME 50000
302 };
303
304 static void
305 window_copy_scroll_timer(__unused int fd, __unused short events, void *arg)
306 {
307 struct window_mode_entry *wme = arg;
308 struct window_pane *wp = wme->wp;
309 struct window_copy_mode_data *data = wme->data;
310 struct timeval tv = {
311 .tv_usec = WINDOW_COPY_DRAG_REPEAT_TIME
312 };
313
314 evtimer_del(&data->dragtimer);
315
316 if (TAILQ_FIRST(&wp->modes) != wme)
317 return;
318
319 if (data->cy == 0) {
320 evtimer_add(&data->dragtimer, &tv);
321 window_copy_cursor_up(wme, 1);
322 } else if (data->cy == screen_size_y(&data->screen) - 1) {
323 evtimer_add(&data->dragtimer, &tv);
324 window_copy_cursor_down(wme, 1);
325 }
326 }
327
328 static struct screen *
329 window_copy_clone_screen(struct screen *src, struct screen *hint, u_int *cx,
330 u_int *cy, int trim)
331 {
332 struct screen *dst;
333 const struct grid_line *gl;
334 u_int sy, wx, wy;
335 int reflow;
336
337 dst = xcalloc(1, sizeof *dst);
338
339 sy = screen_hsize(src) + screen_size_y(src);
340 if (trim) {
341 while (sy > screen_hsize(src)) {
342 gl = grid_peek_line(src->grid, sy - 1);
343 if (gl->cellused != 0)
344 break;
345 sy--;
346 }
347 }
348 log_debug("%s: target screen is %ux%u, source %ux%u", __func__,
349 screen_size_x(src), sy, screen_size_x(hint),
350 screen_hsize(src) + screen_size_y(src));
351 screen_init(dst, screen_size_x(src), sy, screen_hlimit(src));
352
353 /*
354 * Ensure history is on for the backing grid so lines are not deleted
355 * during resizing.
356 */
357 dst->grid->flags |= GRID_HISTORY;
358 grid_duplicate_lines(dst->grid, 0, src->grid, 0, sy);
359
360 dst->grid->sy = sy - screen_hsize(src);
361 dst->grid->hsize = screen_hsize(src);
362 dst->grid->hscrolled = src->grid->hscrolled;
363 if (src->cy > dst->grid->sy - 1) {
364 dst->cx = 0;
365 dst->cy = dst->grid->sy - 1;
366 } else {
367 dst->cx = src->cx;
368 dst->cy = src->cy;
369 }
370
371 if (cx != NULL && cy != NULL) {
372 *cx = dst->cx;
373 *cy = screen_hsize(dst) + dst->cy;
374 reflow = (screen_size_x(hint) != screen_size_x(dst));
375 }
376 else
377 reflow = 0;
378 if (reflow)
379 grid_wrap_position(dst->grid, *cx, *cy, &wx, &wy);
380 screen_resize_cursor(dst, screen_size_x(hint), screen_size_y(hint), 1,
381 0, 0);
382 if (reflow)
383 grid_unwrap_position(dst->grid, cx, cy, wx, wy);
384
385 return (dst);
386 }
387
388 static struct window_copy_mode_data *
389 window_copy_common_init(struct window_mode_entry *wme)
390 {
391 struct window_pane *wp = wme->wp;
392 struct window_copy_mode_data *data;
393 struct screen *base = &wp->base;
394
395 wme->data = data = xcalloc(1, sizeof *data);
396
397 data->cursordrag = CURSORDRAG_NONE;
398 data->lineflag = LINE_SEL_NONE;
399 data->selflag = SEL_CHAR;
400
401 if (wp->searchstr != NULL) {
402 data->searchtype = WINDOW_COPY_SEARCHUP;
403 data->searchregex = wp->searchregex;
404 data->searchstr = xstrdup(wp->searchstr);
405 } else {
406 data->searchtype = WINDOW_COPY_OFF;
407 data->searchregex = 0;
408 data->searchstr = NULL;
409 }
410 data->searchx = data->searchy = data->searcho = -1;
411 data->searchall = 1;
412
413 data->jumptype = WINDOW_COPY_OFF;
414 data->jumpchar = NULL;
415
416 screen_init(&data->screen, screen_size_x(base), screen_size_y(base), 0);
417 data->modekeys = options_get_number(wp->window->options, "mode-keys");
418
419 evtimer_set(&data->dragtimer, window_copy_scroll_timer, wme);
420
421 return (data);
422 }
423
424 static struct screen *
425 window_copy_init(struct window_mode_entry *wme,
426 __unused struct cmd_find_state *fs, struct args *args)
427 {
428 struct window_pane *wp = wme->swp;
429 struct window_copy_mode_data *data;
430 struct screen *base = &wp->base;
431 struct screen_write_ctx ctx;
432 u_int i, cx, cy;
433
434 data = window_copy_common_init(wme);
435 data->backing = window_copy_clone_screen(base, &data->screen, &cx, &cy,
436 wme->swp != wme->wp);
437
438 data->cx = cx;
439 if (cy < screen_hsize(data->backing)) {
440 data->cy = 0;
441 data->oy = screen_hsize(data->backing) - cy;
442 } else {
443 data->cy = cy - screen_hsize(data->backing);
444 data->oy = 0;
445 }
446
447 data->scroll_exit = args_has(args, 'e');
448 data->hide_position = args_has(args, 'H');
449
450 data->screen.cx = data->cx;
451 data->screen.cy = data->cy;
452 data->mx = data->cx;
453 data->my = screen_hsize(data->backing) + data->cy - data->oy;
454 data->showmark = 0;
455
456 screen_write_start(&ctx, &data->screen);
457 for (i = 0; i < screen_size_y(&data->screen); i++)
458 window_copy_write_line(wme, &ctx, i);
459 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
460 screen_write_stop(&ctx);
461
462 return (&data->screen);
463 }
464
465 static struct screen *
466 window_copy_view_init(struct window_mode_entry *wme,
467 __unused struct cmd_find_state *fs, __unused struct args *args)
468 {
469 struct window_pane *wp = wme->wp;
470 struct window_copy_mode_data *data;
471 struct screen *base = &wp->base;
472 u_int sx = screen_size_x(base);
473
474 data = window_copy_common_init(wme);
475 data->viewmode = 1;
476
477 data->backing = xmalloc(sizeof *data->backing);
478 screen_init(data->backing, sx, screen_size_y(base), UINT_MAX);
479 data->writing = xmalloc(sizeof *data->writing);
480 screen_init(data->writing, sx, screen_size_y(base), 0);
481 data->ictx = input_init(NULL, NULL, NULL);
482 data->mx = data->cx;
483 data->my = screen_hsize(data->backing) + data->cy - data->oy;
484 data->showmark = 0;
485
486 return (&data->screen);
487 }
488
489 static void
490 window_copy_free(struct window_mode_entry *wme)
491 {
492 struct window_copy_mode_data *data = wme->data;
493
494 evtimer_del(&data->dragtimer);
495
496 free(data->searchmark);
497 free(data->searchstr);
498 free(data->jumpchar);
499
500 if (data->writing != NULL) {
501 screen_free(data->writing);
502 free(data->writing);
503 }
504 if (data->ictx != NULL)
505 input_free(data->ictx);
506 screen_free(data->backing);
507 free(data->backing);
508
509 screen_free(&data->screen);
510 free(data);
511 }
512
513 void
514 window_copy_add(struct window_pane *wp, int parse, const char *fmt, ...)
515 {
516 va_list ap;
517
518 va_start(ap, fmt);
519 window_copy_vadd(wp, parse, fmt, ap);
520 va_end(ap);
521 }
522
523 static void
524 window_copy_init_ctx_cb(__unused struct screen_write_ctx *ctx,
525 struct tty_ctx *ttyctx)
526 {
527 memcpy(&ttyctx->defaults, &grid_default_cell, sizeof ttyctx->defaults);
528 ttyctx->palette = NULL;
529 ttyctx->redraw_cb = NULL;
530 ttyctx->set_client_cb = NULL;
531 ttyctx->arg = NULL;
532 }
533
534 void
535 window_copy_vadd(struct window_pane *wp, int parse, const char *fmt, va_list ap)
536 {
537 struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
538 struct window_copy_mode_data *data = wme->data;
539 struct screen *backing = data->backing;
540 struct screen *writing = data->writing;
541 struct screen_write_ctx writing_ctx, backing_ctx, ctx;
542 struct grid_cell gc;
543 u_int old_hsize, old_cy;
544 u_int sx = screen_size_x(backing);
545 char *text;
546
547 if (parse) {
548 vasprintf(&text, fmt, ap);
549 screen_write_start(&writing_ctx, writing);
550 screen_write_reset(&writing_ctx);
551 input_parse_screen(data->ictx, writing, window_copy_init_ctx_cb,
552 data, text, strlen(text));
553 free(text);
554 }
555
556 old_hsize = screen_hsize(data->backing);
557 screen_write_start(&backing_ctx, backing);
558 if (data->backing_written) {
559 /*
560 * On the second or later line, do a CRLF before writing
561 * (so it's on a new line).
562 */
563 screen_write_carriagereturn(&backing_ctx);
564 screen_write_linefeed(&backing_ctx, 0, 8);
565 } else
566 data->backing_written = 1;
567 old_cy = backing->cy;
568 if (parse)
569 screen_write_fast_copy(&backing_ctx, writing, 0, 0, sx, 1);
570 else {
571 memcpy(&gc, &grid_default_cell, sizeof gc);
572 screen_write_vnputs(&backing_ctx, 0, &gc, fmt, ap);
573 }
574 screen_write_stop(&backing_ctx);
575
576 data->oy += screen_hsize(data->backing) - old_hsize;
577
578 screen_write_start_pane(&ctx, wp, &data->screen);
579
580 /*
581 * If the history has changed, draw the top line.
582 * (If there's any history at all, it has changed.)
583 */
584 if (screen_hsize(data->backing))
585 window_copy_redraw_lines(wme, 0, 1);
586
587 /* Write the new lines. */
588 window_copy_redraw_lines(wme, old_cy, backing->cy - old_cy + 1);
589
590 screen_write_stop(&ctx);
591 }
592
593 void
594 window_copy_pageup(struct window_pane *wp, int half_page)
595 {
596 window_copy_pageup1(TAILQ_FIRST(&wp->modes), half_page);
597 }
598
599 static void
600 window_copy_pageup1(struct window_mode_entry *wme, int half_page)
601 {
602 struct window_copy_mode_data *data = wme->data;
603 struct screen *s = &data->screen;
604 u_int n, ox, oy, px, py;
605
606 oy = screen_hsize(data->backing) + data->cy - data->oy;
607 ox = window_copy_find_length(wme, oy);
608
609 if (data->cx != ox) {
610 data->lastcx = data->cx;
611 data->lastsx = ox;
612 }
613 data->cx = data->lastcx;
614
615 n = 1;
616 if (screen_size_y(s) > 2) {
617 if (half_page)
618 n = screen_size_y(s) / 2;
619 else
620 n = screen_size_y(s) - 2;
621 }
622
623 if (data->oy + n > screen_hsize(data->backing)) {
624 data->oy = screen_hsize(data->backing);
625 if (data->cy < n)
626 data->cy = 0;
627 else
628 data->cy -= n;
629 } else
630 data->oy += n;
631
632 if (data->screen.sel == NULL || !data->rectflag) {
633 py = screen_hsize(data->backing) + data->cy - data->oy;
634 px = window_copy_find_length(wme, py);
635 if ((data->cx >= data->lastsx && data->cx != px) ||
636 data->cx > px)
637 window_copy_cursor_end_of_line(wme);
638 }
639
640 if (data->searchmark != NULL && !data->timeout)
641 window_copy_search_marks(wme, NULL, data->searchregex, 1);
642 window_copy_update_selection(wme, 1, 0);
643 window_copy_redraw_screen(wme);
644 }
645
646 static int
647 window_copy_pagedown(struct window_mode_entry *wme, int half_page,
648 int scroll_exit)
649 {
650 struct window_copy_mode_data *data = wme->data;
651 struct screen *s = &data->screen;
652 u_int n, ox, oy, px, py;
653
654 oy = screen_hsize(data->backing) + data->cy - data->oy;
655 ox = window_copy_find_length(wme, oy);
656
657 if (data->cx != ox) {
658 data->lastcx = data->cx;
659 data->lastsx = ox;
660 }
661 data->cx = data->lastcx;
662
663 n = 1;
664 if (screen_size_y(s) > 2) {
665 if (half_page)
666 n = screen_size_y(s) / 2;
667 else
668 n = screen_size_y(s) - 2;
669 }
670
671 if (data->oy < n) {
672 data->oy = 0;
673 if (data->cy + (n - data->oy) >= screen_size_y(data->backing))
674 data->cy = screen_size_y(data->backing) - 1;
675 else
676 data->cy += n - data->oy;
677 } else
678 data->oy -= n;
679
680 if (data->screen.sel == NULL || !data->rectflag) {
681 py = screen_hsize(data->backing) + data->cy - data->oy;
682 px = window_copy_find_length(wme, py);
683 if ((data->cx >= data->lastsx && data->cx != px) ||
684 data->cx > px)
685 window_copy_cursor_end_of_line(wme);
686 }
687
688 if (scroll_exit && data->oy == 0)
689 return (1);
690 if (data->searchmark != NULL && !data->timeout)
691 window_copy_search_marks(wme, NULL, data->searchregex, 1);
692 window_copy_update_selection(wme, 1, 0);
693 window_copy_redraw_screen(wme);
694 return (0);
695 }
696
697 static void
698 window_copy_previous_paragraph(struct window_mode_entry *wme)
699 {
700 struct window_copy_mode_data *data = wme->data;
701 u_int oy;
702
703 oy = screen_hsize(data->backing) + data->cy - data->oy;
704
705 while (oy > 0 && window_copy_find_length(wme, oy) == 0)
706 oy--;
707
708 while (oy > 0 && window_copy_find_length(wme, oy) > 0)
709 oy--;
710
711 window_copy_scroll_to(wme, 0, oy, 0);
712 }
713
714 static void
715 window_copy_next_paragraph(struct window_mode_entry *wme)
716 {
717 struct window_copy_mode_data *data = wme->data;
718 struct screen *s = &data->screen;
719 u_int maxy, ox, oy;
720
721 oy = screen_hsize(data->backing) + data->cy - data->oy;
722 maxy = screen_hsize(data->backing) + screen_size_y(s) - 1;
723
724 while (oy < maxy && window_copy_find_length(wme, oy) == 0)
725 oy++;
726
727 while (oy < maxy && window_copy_find_length(wme, oy) > 0)
728 oy++;
729
730 ox = window_copy_find_length(wme, oy);
731 window_copy_scroll_to(wme, ox, oy, 0);
732 }
733
734 char *
735 window_copy_get_word(struct window_pane *wp, u_int x, u_int y)
736 {
737 struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
738 struct window_copy_mode_data *data = wme->data;
739 struct grid *gd = data->screen.grid;
740
741 return (format_grid_word(gd, x, gd->hsize + y));
742 }
743
744 char *
745 window_copy_get_line(struct window_pane *wp, u_int y)
746 {
747 struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
748 struct window_copy_mode_data *data = wme->data;
749 struct grid *gd = data->screen.grid;
750
751 return (format_grid_line(gd, gd->hsize + y));
752 }
753
754 static void *
755 window_copy_cursor_word_cb(struct format_tree *ft)
756 {
757 struct window_pane *wp = format_get_pane(ft);
758 struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
759 struct window_copy_mode_data *data = wme->data;
760
761 return (window_copy_get_word(wp, data->cx, data->cy));
762 }
763
764 static void *
765 window_copy_cursor_line_cb(struct format_tree *ft)
766 {
767 struct window_pane *wp = format_get_pane(ft);
768 struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
769 struct window_copy_mode_data *data = wme->data;
770
771 return (window_copy_get_line(wp, data->cy));
772 }
773
774 static void *
775 window_copy_search_match_cb(struct format_tree *ft)
776 {
777 struct window_pane *wp = format_get_pane(ft);
778 struct window_mode_entry *wme = TAILQ_FIRST(&wp->modes);
779 struct window_copy_mode_data *data = wme->data;
780
781 return (window_copy_match_at_cursor(data));
782 }
783
784 static void
785 window_copy_formats(struct window_mode_entry *wme, struct format_tree *ft)
786 {
787 struct window_copy_mode_data *data = wme->data;
788
789 format_add(ft, "scroll_position", "%d", data->oy);
790 format_add(ft, "rectangle_toggle", "%d", data->rectflag);
791
792 format_add(ft, "copy_cursor_x", "%d", data->cx);
793 format_add(ft, "copy_cursor_y", "%d", data->cy);
794
795 format_add(ft, "selection_present", "%d", data->screen.sel != NULL);
796 if (data->screen.sel != NULL) {
797 format_add(ft, "selection_start_x", "%d", data->selx);
798 format_add(ft, "selection_start_y", "%d", data->sely);
799 format_add(ft, "selection_end_x", "%d", data->endselx);
800 format_add(ft, "selection_end_y", "%d", data->endsely);
801 format_add(ft, "selection_active", "%d",
802 data->cursordrag != CURSORDRAG_NONE);
803 } else
804 format_add(ft, "selection_active", "%d", 0);
805
806 format_add(ft, "search_present", "%d", data->searchmark != NULL);
807 format_add_cb(ft, "search_match", window_copy_search_match_cb);
808
809 format_add_cb(ft, "copy_cursor_word", window_copy_cursor_word_cb);
810 format_add_cb(ft, "copy_cursor_line", window_copy_cursor_line_cb);
811 }
812
813 static void
814 window_copy_size_changed(struct window_mode_entry *wme)
815 {
816 struct window_copy_mode_data *data = wme->data;
817 struct screen *s = &data->screen;
818 struct screen_write_ctx ctx;
819 int search = (data->searchmark != NULL);
820
821 window_copy_clear_selection(wme);
822 window_copy_clear_marks(wme);
823
824 screen_write_start(&ctx, s);
825 window_copy_write_lines(wme, &ctx, 0, screen_size_y(s));
826 screen_write_stop(&ctx);
827
828 if (search && !data->timeout)
829 window_copy_search_marks(wme, NULL, data->searchregex, 0);
830 data->searchx = data->cx;
831 data->searchy = data->cy;
832 data->searcho = data->oy;
833 }
834
835 static void
836 window_copy_resize(struct window_mode_entry *wme, u_int sx, u_int sy)
837 {
838 struct window_copy_mode_data *data = wme->data;
839 struct screen *s = &data->screen;
840 struct grid *gd = data->backing->grid;
841 u_int cx, cy, wx, wy;
842 int reflow;
843
844 screen_resize(s, sx, sy, 0);
845 cx = data->cx;
846 cy = gd->hsize + data->cy - data->oy;
847 reflow = (gd->sx != sx);
848 if (reflow)
849 grid_wrap_position(gd, cx, cy, &wx, &wy);
850 screen_resize_cursor(data->backing, sx, sy, 1, 0, 0);
851 if (reflow)
852 grid_unwrap_position(gd, &cx, &cy, wx, wy);
853
854 data->cx = cx;
855 if (cy < gd->hsize) {
856 data->cy = 0;
857 data->oy = gd->hsize - cy;
858 } else {
859 data->cy = cy - gd->hsize;
860 data->oy = 0;
861 }
862
863 window_copy_size_changed(wme);
864 window_copy_redraw_screen(wme);
865 }
866
867 static const char *
868 window_copy_key_table(struct window_mode_entry *wme)
869 {
870 struct window_pane *wp = wme->wp;
871
872 if (options_get_number(wp->window->options, "mode-keys") == MODEKEY_VI)
873 return ("copy-mode-vi");
874 return ("copy-mode");
875 }
876
877 static int
878 window_copy_expand_search_string(struct window_copy_cmd_state *cs)
879 {
880 struct window_mode_entry *wme = cs->wme;
881 struct window_copy_mode_data *data = wme->data;
882 const char *ss = args_string(cs->args, 1);
883 char *expanded;
884
885 if (ss == NULL || *ss == '\0')
886 return (0);
887
888 if (args_has(cs->args, 'F')) {
889 expanded = format_single(NULL, ss, NULL, NULL, NULL, wme->wp);
890 if (*expanded == '\0') {
891 free(expanded);
892 return (0);
893 }
894 free(data->searchstr);
895 data->searchstr = expanded;
896 } else {
897 free(data->searchstr);
898 data->searchstr = xstrdup(ss);
899 }
900 return (1);
901 }
902
903 static enum window_copy_cmd_action
904 window_copy_cmd_append_selection(struct window_copy_cmd_state *cs)
905 {
906 struct window_mode_entry *wme = cs->wme;
907 struct session *s = cs->s;
908
909 if (s != NULL)
910 window_copy_append_selection(wme);
911 window_copy_clear_selection(wme);
912 return (WINDOW_COPY_CMD_REDRAW);
913 }
914
915 static enum window_copy_cmd_action
916 window_copy_cmd_append_selection_and_cancel(struct window_copy_cmd_state *cs)
917 {
918 struct window_mode_entry *wme = cs->wme;
919 struct session *s = cs->s;
920
921 if (s != NULL)
922 window_copy_append_selection(wme);
923 window_copy_clear_selection(wme);
924 return (WINDOW_COPY_CMD_CANCEL);
925 }
926
927 static enum window_copy_cmd_action
928 window_copy_cmd_back_to_indentation(struct window_copy_cmd_state *cs)
929 {
930 struct window_mode_entry *wme = cs->wme;
931
932 window_copy_cursor_back_to_indentation(wme);
933 return (WINDOW_COPY_CMD_NOTHING);
934 }
935
936 static enum window_copy_cmd_action
937 window_copy_cmd_begin_selection(struct window_copy_cmd_state *cs)
938 {
939 struct window_mode_entry *wme = cs->wme;
940 struct client *c = cs->c;
941 struct mouse_event *m = cs->m;
942 struct window_copy_mode_data *data = wme->data;
943
944 if (m != NULL) {
945 window_copy_start_drag(c, m);
946 return (WINDOW_COPY_CMD_NOTHING);
947 }
948
949 data->lineflag = LINE_SEL_NONE;
950 data->selflag = SEL_CHAR;
951 window_copy_start_selection(wme);
952 return (WINDOW_COPY_CMD_REDRAW);
953 }
954
955 static enum window_copy_cmd_action
956 window_copy_cmd_stop_selection(struct window_copy_cmd_state *cs)
957 {
958 struct window_mode_entry *wme = cs->wme;
959 struct window_copy_mode_data *data = wme->data;
960
961 data->cursordrag = CURSORDRAG_NONE;
962 data->lineflag = LINE_SEL_NONE;
963 data->selflag = SEL_CHAR;
964 return (WINDOW_COPY_CMD_NOTHING);
965 }
966
967 static enum window_copy_cmd_action
968 window_copy_cmd_bottom_line(struct window_copy_cmd_state *cs)
969 {
970 struct window_mode_entry *wme = cs->wme;
971 struct window_copy_mode_data *data = wme->data;
972
973 data->cx = 0;
974 data->cy = screen_size_y(&data->screen) - 1;
975
976 window_copy_update_selection(wme, 1, 0);
977 return (WINDOW_COPY_CMD_REDRAW);
978 }
979
980 static enum window_copy_cmd_action
981 window_copy_cmd_cancel(__unused struct window_copy_cmd_state *cs)
982 {
983 return (WINDOW_COPY_CMD_CANCEL);
984 }
985
986 static enum window_copy_cmd_action
987 window_copy_cmd_clear_selection(struct window_copy_cmd_state *cs)
988 {
989 struct window_mode_entry *wme = cs->wme;
990
991 window_copy_clear_selection(wme);
992 return (WINDOW_COPY_CMD_REDRAW);
993 }
994
995 static enum window_copy_cmd_action
996 window_copy_do_copy_end_of_line(struct window_copy_cmd_state *cs, int pipe,
997 int cancel)
998 {
999 struct window_mode_entry *wme = cs->wme;
1000 struct client *c = cs->c;
1001 struct session *s = cs->s;
1002 struct winlink *wl = cs->wl;
1003 struct window_pane *wp = wme->wp;
1004 u_int count = args_count(cs->args);
1005 u_int np = wme->prefix, ocx, ocy, ooy;
1006 struct window_copy_mode_data *data = wme->data;
1007 char *prefix = NULL, *command = NULL;
1008 const char *arg1 = args_string(cs->args, 1);
1009 const char *arg2 = args_string(cs->args, 2);
1010
1011 if (pipe) {
1012 if (count == 3)
1013 prefix = format_single(NULL, arg2, c, s, wl, wp);
1014 if (s != NULL && count > 1 && *arg1 != '\0')
1015 command = format_single(NULL, arg1, c, s, wl, wp);
1016 } else {
1017 if (count == 2)
1018 prefix = format_single(NULL, arg1, c, s, wl, wp);
1019 }
1020
1021 ocx = data->cx;
1022 ocy = data->cy;
1023 ooy = data->oy;
1024
1025 window_copy_start_selection(wme);
1026 for (; np > 1; np--)
1027 window_copy_cursor_down(wme, 0);
1028 window_copy_cursor_end_of_line(wme);
1029
1030 if (s != NULL) {
1031 if (pipe)
1032 window_copy_copy_pipe(wme, s, prefix, command);
1033 else
1034 window_copy_copy_selection(wme, prefix);
1035
1036 if (cancel) {
1037 free(prefix);
1038 free(command);
1039 return (WINDOW_COPY_CMD_CANCEL);
1040 }
1041 }
1042 window_copy_clear_selection(wme);
1043
1044 data->cx = ocx;
1045 data->cy = ocy;
1046 data->oy = ooy;
1047
1048 free(prefix);
1049 free(command);
1050 return (WINDOW_COPY_CMD_REDRAW);
1051 }
1052
1053 static enum window_copy_cmd_action
1054 window_copy_cmd_copy_end_of_line(struct window_copy_cmd_state *cs)
1055 {
1056 return (window_copy_do_copy_end_of_line(cs, 0, 0));
1057 }
1058
1059 static enum window_copy_cmd_action
1060 window_copy_cmd_copy_end_of_line_and_cancel(struct window_copy_cmd_state *cs)
1061 {
1062 return (window_copy_do_copy_end_of_line(cs, 0, 1));
1063 }
1064
1065 static enum window_copy_cmd_action
1066 window_copy_cmd_copy_pipe_end_of_line(struct window_copy_cmd_state *cs)
1067 {
1068 return (window_copy_do_copy_end_of_line(cs, 1, 0));
1069 }
1070
1071 static enum window_copy_cmd_action
1072 window_copy_cmd_copy_pipe_end_of_line_and_cancel(
1073 struct window_copy_cmd_state *cs)
1074 {
1075 return (window_copy_do_copy_end_of_line(cs, 1, 1));
1076 }
1077
1078 static enum window_copy_cmd_action
1079 window_copy_do_copy_line(struct window_copy_cmd_state *cs, int pipe, int cancel)
1080 {
1081 struct window_mode_entry *wme = cs->wme;
1082 struct client *c = cs->c;
1083 struct session *s = cs->s;
1084 struct winlink *wl = cs->wl;
1085 struct window_pane *wp = wme->wp;
1086 struct window_copy_mode_data *data = wme->data;
1087 u_int count = args_count(cs->args);
1088 u_int np = wme->prefix, ocx, ocy, ooy;
1089 char *prefix = NULL, *command = NULL;
1090 const char *arg1 = args_string(cs->args, 1);
1091 const char *arg2 = args_string(cs->args, 2);
1092
1093 if (pipe) {
1094 if (count == 3)
1095 prefix = format_single(NULL, arg2, c, s, wl, wp);
1096 if (s != NULL && count > 1 && *arg1 != '\0')
1097 command = format_single(NULL, arg1, c, s, wl, wp);
1098 } else {
1099 if (count == 2)
1100 prefix = format_single(NULL, arg1, c, s, wl, wp);
1101 }
1102
1103 ocx = data->cx;
1104 ocy = data->cy;
1105 ooy = data->oy;
1106
1107 data->selflag = SEL_CHAR;
1108 window_copy_cursor_start_of_line(wme);
1109 window_copy_start_selection(wme);
1110 for (; np > 1; np--)
1111 window_copy_cursor_down(wme, 0);
1112 window_copy_cursor_end_of_line(wme);
1113
1114 if (s != NULL) {
1115 if (pipe)
1116 window_copy_copy_pipe(wme, s, prefix, command);
1117 else
1118 window_copy_copy_selection(wme, prefix);
1119
1120 if (cancel) {
1121 free(prefix);
1122 free(command);
1123 return (WINDOW_COPY_CMD_CANCEL);
1124 }
1125 }
1126 window_copy_clear_selection(wme);
1127
1128 data->cx = ocx;
1129 data->cy = ocy;
1130 data->oy = ooy;
1131
1132 free(prefix);
1133 free(command);
1134 return (WINDOW_COPY_CMD_REDRAW);
1135 }
1136
1137 static enum window_copy_cmd_action
1138 window_copy_cmd_copy_line(struct window_copy_cmd_state *cs)
1139 {
1140 return (window_copy_do_copy_line(cs, 0, 0));
1141 }
1142
1143 static enum window_copy_cmd_action
1144 window_copy_cmd_copy_line_and_cancel(struct window_copy_cmd_state *cs)
1145 {
1146 return (window_copy_do_copy_line(cs, 0, 1));
1147 }
1148
1149 static enum window_copy_cmd_action
1150 window_copy_cmd_copy_pipe_line(struct window_copy_cmd_state *cs)
1151 {
1152 return (window_copy_do_copy_line(cs, 1, 0));
1153 }
1154
1155 static enum window_copy_cmd_action
1156 window_copy_cmd_copy_pipe_line_and_cancel(struct window_copy_cmd_state *cs)
1157 {
1158 return (window_copy_do_copy_line(cs, 1, 1));
1159 }
1160
1161 static enum window_copy_cmd_action
1162 window_copy_cmd_copy_selection_no_clear(struct window_copy_cmd_state *cs)
1163 {
1164 struct window_mode_entry *wme = cs->wme;
1165 struct client *c = cs->c;
1166 struct session *s = cs->s;
1167 struct winlink *wl = cs->wl;
1168 struct window_pane *wp = wme->wp;
1169 char *prefix = NULL;
1170 const char *arg1 = args_string(cs->args, 1);
1171
1172 if (arg1 != NULL)
1173 prefix = format_single(NULL, arg1, c, s, wl, wp);
1174
1175 if (s != NULL)
1176 window_copy_copy_selection(wme, prefix);
1177
1178 free(prefix);
1179 return (WINDOW_COPY_CMD_NOTHING);
1180 }
1181
1182 static enum window_copy_cmd_action
1183 window_copy_cmd_copy_selection(struct window_copy_cmd_state *cs)
1184 {
1185 struct window_mode_entry *wme = cs->wme;
1186
1187 window_copy_cmd_copy_selection_no_clear(cs);
1188 window_copy_clear_selection(wme);
1189 return (WINDOW_COPY_CMD_REDRAW);
1190 }
1191
1192 static enum window_copy_cmd_action
1193 window_copy_cmd_copy_selection_and_cancel(struct window_copy_cmd_state *cs)
1194 {
1195 struct window_mode_entry *wme = cs->wme;
1196
1197 window_copy_cmd_copy_selection_no_clear(cs);
1198 window_copy_clear_selection(wme);
1199 return (WINDOW_COPY_CMD_CANCEL);
1200 }
1201
1202 static enum window_copy_cmd_action
1203 window_copy_cmd_cursor_down(struct window_copy_cmd_state *cs)
1204 {
1205 struct window_mode_entry *wme = cs->wme;
1206 u_int np = wme->prefix;
1207
1208 for (; np != 0; np--)
1209 window_copy_cursor_down(wme, 0);
1210 return (WINDOW_COPY_CMD_NOTHING);
1211 }
1212
1213 static enum window_copy_cmd_action
1214 window_copy_cmd_cursor_down_and_cancel(struct window_copy_cmd_state *cs)
1215 {
1216 struct window_mode_entry *wme = cs->wme;
1217 struct window_copy_mode_data *data = wme->data;
1218 u_int np = wme->prefix, cy;
1219
1220 cy = data->cy;
1221 for (; np != 0; np--)
1222 window_copy_cursor_down(wme, 0);
1223 if (cy == data->cy && data->oy == 0)
1224 return (WINDOW_COPY_CMD_CANCEL);
1225 return (WINDOW_COPY_CMD_NOTHING);
1226 }
1227
1228 static enum window_copy_cmd_action
1229 window_copy_cmd_cursor_left(struct window_copy_cmd_state *cs)
1230 {
1231 struct window_mode_entry *wme = cs->wme;
1232 u_int np = wme->prefix;
1233
1234 for (; np != 0; np--)
1235 window_copy_cursor_left(wme);
1236 return (WINDOW_COPY_CMD_NOTHING);
1237 }
1238
1239 static enum window_copy_cmd_action
1240 window_copy_cmd_cursor_right(struct window_copy_cmd_state *cs)
1241 {
1242 struct window_mode_entry *wme = cs->wme;
1243 struct window_copy_mode_data *data = wme->data;
1244 u_int np = wme->prefix;
1245
1246 for (; np != 0; np--) {
1247 window_copy_cursor_right(wme, data->screen.sel != NULL &&
1248 data->rectflag);
1249 }
1250 return (WINDOW_COPY_CMD_NOTHING);
1251 }
1252
1253 static enum window_copy_cmd_action
1254 window_copy_cmd_cursor_up(struct window_copy_cmd_state *cs)
1255 {
1256 struct window_mode_entry *wme = cs->wme;
1257 u_int np = wme->prefix;
1258
1259 for (; np != 0; np--)
1260 window_copy_cursor_up(wme, 0);
1261 return (WINDOW_COPY_CMD_NOTHING);
1262 }
1263
1264 static enum window_copy_cmd_action
1265 window_copy_cmd_end_of_line(struct window_copy_cmd_state *cs)
1266 {
1267 struct window_mode_entry *wme = cs->wme;
1268
1269 window_copy_cursor_end_of_line(wme);
1270 return (WINDOW_COPY_CMD_NOTHING);
1271 }
1272
1273 static enum window_copy_cmd_action
1274 window_copy_cmd_halfpage_down(struct window_copy_cmd_state *cs)
1275 {
1276 struct window_mode_entry *wme = cs->wme;
1277 struct window_copy_mode_data *data = wme->data;
1278 u_int np = wme->prefix;
1279
1280 for (; np != 0; np--) {
1281 if (window_copy_pagedown(wme, 1, data->scroll_exit))
1282 return (WINDOW_COPY_CMD_CANCEL);
1283 }
1284 return (WINDOW_COPY_CMD_NOTHING);
1285 }
1286
1287 static enum window_copy_cmd_action
1288 window_copy_cmd_halfpage_down_and_cancel(struct window_copy_cmd_state *cs)
1289 {
1290
1291 struct window_mode_entry *wme = cs->wme;
1292 u_int np = wme->prefix;
1293
1294 for (; np != 0; np--) {
1295 if (window_copy_pagedown(wme, 1, 1))
1296 return (WINDOW_COPY_CMD_CANCEL);
1297 }
1298 return (WINDOW_COPY_CMD_NOTHING);
1299 }
1300
1301 static enum window_copy_cmd_action
1302 window_copy_cmd_halfpage_up(struct window_copy_cmd_state *cs)
1303 {
1304 struct window_mode_entry *wme = cs->wme;
1305 u_int np = wme->prefix;
1306
1307 for (; np != 0; np--)
1308 window_copy_pageup1(wme, 1);
1309 return (WINDOW_COPY_CMD_NOTHING);
1310 }
1311
1312 static enum window_copy_cmd_action
1313 window_copy_cmd_toggle_position(struct window_copy_cmd_state *cs)
1314 {
1315 struct window_mode_entry *wme = cs->wme;
1316 struct window_copy_mode_data *data = wme->data;
1317
1318 data->hide_position = !data->hide_position;
1319 return (WINDOW_COPY_CMD_REDRAW);
1320 }
1321
1322 static enum window_copy_cmd_action
1323 window_copy_cmd_history_bottom(struct window_copy_cmd_state *cs)
1324 {
1325 struct window_mode_entry *wme = cs->wme;
1326 struct window_copy_mode_data *data = wme->data;
1327 struct screen *s = data->backing;
1328 u_int oy;
1329
1330 oy = screen_hsize(s) + data->cy - data->oy;
1331 if (data->lineflag == LINE_SEL_RIGHT_LEFT && oy == data->endsely)
1332 window_copy_other_end(wme);
1333
1334 data->cy = screen_size_y(&data->screen) - 1;
1335 data->cx = window_copy_find_length(wme, screen_hsize(s) + data->cy);
1336 data->oy = 0;
1337
1338 if (data->searchmark != NULL && !data->timeout)
1339 window_copy_search_marks(wme, NULL, data->searchregex, 1);
1340 window_copy_update_selection(wme, 1, 0);
1341 return (WINDOW_COPY_CMD_REDRAW);
1342 }
1343
1344 static enum window_copy_cmd_action
1345 window_copy_cmd_history_top(struct window_copy_cmd_state *cs)
1346 {
1347 struct window_mode_entry *wme = cs->wme;
1348 struct window_copy_mode_data *data = wme->data;
1349 u_int oy;
1350
1351 oy = screen_hsize(data->backing) + data->cy - data->oy;
1352 if (data->lineflag == LINE_SEL_LEFT_RIGHT && oy == data->sely)
1353 window_copy_other_end(wme);
1354
1355 data->cy = 0;
1356 data->cx = 0;
1357 data->oy = screen_hsize(data->backing);
1358
1359 if (data->searchmark != NULL && !data->timeout)
1360 window_copy_search_marks(wme, NULL, data->searchregex, 1);
1361 window_copy_update_selection(wme, 1, 0);
1362 return (WINDOW_COPY_CMD_REDRAW);
1363 }
1364
1365 static enum window_copy_cmd_action
1366 window_copy_cmd_jump_again(struct window_copy_cmd_state *cs)
1367 {
1368 struct window_mode_entry *wme = cs->wme;
1369 struct window_copy_mode_data *data = wme->data;
1370 u_int np = wme->prefix;
1371
1372 switch (data->jumptype) {
1373 case WINDOW_COPY_JUMPFORWARD:
1374 for (; np != 0; np--)
1375 window_copy_cursor_jump(wme);
1376 break;
1377 case WINDOW_COPY_JUMPBACKWARD:
1378 for (; np != 0; np--)
1379 window_copy_cursor_jump_back(wme);
1380 break;
1381 case WINDOW_COPY_JUMPTOFORWARD:
1382 for (; np != 0; np--)
1383 window_copy_cursor_jump_to(wme);
1384 break;
1385 case WINDOW_COPY_JUMPTOBACKWARD:
1386 for (; np != 0; np--)
1387 window_copy_cursor_jump_to_back(wme);
1388 break;
1389 }
1390 return (WINDOW_COPY_CMD_NOTHING);
1391 }
1392
1393 static enum window_copy_cmd_action
1394 window_copy_cmd_jump_reverse(struct window_copy_cmd_state *cs)
1395 {
1396 struct window_mode_entry *wme = cs->wme;
1397 struct window_copy_mode_data *data = wme->data;
1398 u_int np = wme->prefix;
1399
1400 switch (data->jumptype) {
1401 case WINDOW_COPY_JUMPFORWARD:
1402 for (; np != 0; np--)
1403 window_copy_cursor_jump_back(wme);
1404 break;
1405 case WINDOW_COPY_JUMPBACKWARD:
1406 for (; np != 0; np--)
1407 window_copy_cursor_jump(wme);
1408 break;
1409 case WINDOW_COPY_JUMPTOFORWARD:
1410 for (; np != 0; np--)
1411 window_copy_cursor_jump_to_back(wme);
1412 break;
1413 case WINDOW_COPY_JUMPTOBACKWARD:
1414 for (; np != 0; np--)
1415 window_copy_cursor_jump_to(wme);
1416 break;
1417 }
1418 return (WINDOW_COPY_CMD_NOTHING);
1419 }
1420
1421 static enum window_copy_cmd_action
1422 window_copy_cmd_middle_line(struct window_copy_cmd_state *cs)
1423 {
1424 struct window_mode_entry *wme = cs->wme;
1425 struct window_copy_mode_data *data = wme->data;
1426
1427 data->cx = 0;
1428 data->cy = (screen_size_y(&data->screen) - 1) / 2;
1429
1430 window_copy_update_selection(wme, 1, 0);
1431 return (WINDOW_COPY_CMD_REDRAW);
1432 }
1433
1434 static enum window_copy_cmd_action
1435 window_copy_cmd_previous_matching_bracket(struct window_copy_cmd_state *cs)
1436 {
1437 struct window_mode_entry *wme = cs->wme;
1438 u_int np = wme->prefix;
1439 struct window_copy_mode_data *data = wme->data;
1440 struct screen *s = data->backing;
1441 char open[] = "{[(", close[] = "}])";
1442 char tried, found, start, *cp;
1443 u_int px, py, xx, n;
1444 struct grid_cell gc;
1445 int failed;
1446
1447 for (; np != 0; np--) {
1448 /* Get cursor position and line length. */
1449 px = data->cx;
1450 py = screen_hsize(s) + data->cy - data->oy;
1451 xx = window_copy_find_length(wme, py);
1452 if (xx == 0)
1453 break;
1454
1455 /*
1456 * Get the current character. If not on a bracket, try the
1457 * previous. If still not, then behave like previous-word.
1458 */
1459 tried = 0;
1460 retry:
1461 grid_get_cell(s->grid, px, py, &gc);
1462 if (gc.data.size != 1 || (gc.flags & GRID_FLAG_PADDING))
1463 cp = NULL;
1464 else {
1465 found = *gc.data.data;
1466 cp = strchr(close, found);
1467 }
1468 if (cp == NULL) {
1469 if (data->modekeys == MODEKEY_EMACS) {
1470 if (!tried && px > 0) {
1471 px--;
1472 tried = 1;
1473 goto retry;
1474 }
1475 window_copy_cursor_previous_word(wme, close, 1);
1476 }
1477 continue;
1478 }
1479 start = open[cp - close];
1480
1481 /* Walk backward until the matching bracket is reached. */
1482 n = 1;
1483 failed = 0;
1484 do {
1485 if (px == 0) {
1486 if (py == 0) {
1487 failed = 1;
1488 break;
1489 }
1490 do {
1491 py--;
1492 xx = window_copy_find_length(wme, py);
1493 } while (xx == 0 && py > 0);
1494 if (xx == 0 && py == 0) {
1495 failed = 1;
1496 break;
1497 }
1498 px = xx - 1;
1499 } else
1500 px--;
1501
1502 grid_get_cell(s->grid, px, py, &gc);
1503 if (gc.data.size == 1 &&
1504 (~gc.flags & GRID_FLAG_PADDING)) {
1505 if (*gc.data.data == found)
1506 n++;
1507 else if (*gc.data.data == start)
1508 n--;
1509 }
1510 } while (n != 0);
1511
1512 /* Move the cursor to the found location if any. */
1513 if (!failed)
1514 window_copy_scroll_to(wme, px, py, 0);
1515 }
1516
1517 return (WINDOW_COPY_CMD_NOTHING);
1518 }
1519
1520 static enum window_copy_cmd_action
1521 window_copy_cmd_next_matching_bracket(struct window_copy_cmd_state *cs)
1522 {
1523 struct window_mode_entry *wme = cs->wme;
1524 u_int np = wme->prefix;
1525 struct window_copy_mode_data *data = wme->data;
1526 struct screen *s = data->backing;
1527 char open[] = "{[(", close[] = "}])";
1528 char tried, found, end, *cp;
1529 u_int px, py, xx, yy, sx, sy, n;
1530 struct grid_cell gc;
1531 int failed;
1532 struct grid_line *gl;
1533
1534 for (; np != 0; np--) {
1535 /* Get cursor position and line length. */
1536 px = data->cx;
1537 py = screen_hsize(s) + data->cy - data->oy;
1538 xx = window_copy_find_length(wme, py);
1539 yy = screen_hsize(s) + screen_size_y(s) - 1;
1540 if (xx == 0)
1541 break;
1542
1543 /*
1544 * Get the current character. If not on a bracket, try the
1545 * next. If still not, then behave like next-word.
1546 */
1547 tried = 0;
1548 retry:
1549 grid_get_cell(s->grid, px, py, &gc);
1550 if (gc.data.size != 1 || (gc.flags & GRID_FLAG_PADDING))
1551 cp = NULL;
1552 else {
1553 found = *gc.data.data;
1554
1555 /*
1556 * In vi mode, attempt to move to previous bracket if a
1557 * closing bracket is found first. If this fails,
1558 * return to the original cursor position.
1559 */
1560 cp = strchr(close, found);
1561 if (cp != NULL && data->modekeys == MODEKEY_VI) {
1562 sx = data->cx;
1563 sy = screen_hsize(s) + data->cy - data->oy;
1564
1565 window_copy_scroll_to(wme, px, py, 0);
1566 window_copy_cmd_previous_matching_bracket(cs);
1567
1568 px = data->cx;
1569 py = screen_hsize(s) + data->cy - data->oy;
1570 grid_get_cell(s->grid, px, py, &gc);
1571 if (gc.data.size == 1 &&
1572 (~gc.flags & GRID_FLAG_PADDING) &&
1573 strchr(close, *gc.data.data) != NULL)
1574 window_copy_scroll_to(wme, sx, sy, 0);
1575 break;
1576 }
1577
1578 cp = strchr(open, found);
1579 }
1580 if (cp == NULL) {
1581 if (data->modekeys == MODEKEY_EMACS) {
1582 if (!tried && px <= xx) {
1583 px++;
1584 tried = 1;
1585 goto retry;
1586 }
1587 window_copy_cursor_next_word_end(wme, open, 0);
1588 continue;
1589 }
1590 /* For vi, continue searching for bracket until EOL. */
1591 if (px > xx) {
1592 if (py == yy)
1593 continue;
1594 gl = grid_get_line(s->grid, py);
1595 if (~gl->flags & GRID_LINE_WRAPPED)
1596 continue;
1597 if (gl->cellsize > s->grid->sx)
1598 continue;
1599 px = 0;
1600 py++;
1601 xx = window_copy_find_length(wme, py);
1602 } else
1603 px++;
1604 goto retry;
1605 }
1606 end = close[cp - open];
1607
1608 /* Walk forward until the matching bracket is reached. */
1609 n = 1;
1610 failed = 0;
1611 do {
1612 if (px > xx) {
1613 if (py == yy) {
1614 failed = 1;
1615 break;
1616 }
1617 px = 0;
1618 py++;
1619 xx = window_copy_find_length(wme, py);
1620 } else
1621 px++;
1622
1623 grid_get_cell(s->grid, px, py, &gc);
1624 if (gc.data.size == 1 &&
1625 (~gc.flags & GRID_FLAG_PADDING)) {
1626 if (*gc.data.data == found)
1627 n++;
1628 else if (*gc.data.data == end)
1629 n--;
1630 }
1631 } while (n != 0);
1632
1633 /* Move the cursor to the found location if any. */
1634 if (!failed)
1635 window_copy_scroll_to(wme, px, py, 0);
1636 }
1637
1638 return (WINDOW_COPY_CMD_NOTHING);
1639 }
1640
1641 static enum window_copy_cmd_action
1642 window_copy_cmd_next_paragraph(struct window_copy_cmd_state *cs)
1643 {
1644 struct window_mode_entry *wme = cs->wme;
1645 u_int np = wme->prefix;
1646
1647 for (; np != 0; np--)
1648 window_copy_next_paragraph(wme);
1649 return (WINDOW_COPY_CMD_NOTHING);
1650 }
1651
1652 static enum window_copy_cmd_action
1653 window_copy_cmd_next_space(struct window_copy_cmd_state *cs)
1654 {
1655 struct window_mode_entry *wme = cs->wme;
1656 u_int np = wme->prefix;
1657
1658 for (; np != 0; np--)
1659 window_copy_cursor_next_word(wme, "");
1660 return (WINDOW_COPY_CMD_NOTHING);
1661 }
1662
1663 static enum window_copy_cmd_action
1664 window_copy_cmd_next_space_end(struct window_copy_cmd_state *cs)
1665 {
1666 struct window_mode_entry *wme = cs->wme;
1667 u_int np = wme->prefix;
1668
1669 for (; np != 0; np--)
1670 window_copy_cursor_next_word_end(wme, "", 0);
1671 return (WINDOW_COPY_CMD_NOTHING);
1672 }
1673
1674 static enum window_copy_cmd_action
1675 window_copy_cmd_next_word(struct window_copy_cmd_state *cs)
1676 {
1677 struct window_mode_entry *wme = cs->wme;
1678 u_int np = wme->prefix;
1679 const char *separators;
1680
1681 separators = options_get_string(cs->s->options, "word-separators");
1682
1683 for (; np != 0; np--)
1684 window_copy_cursor_next_word(wme, separators);
1685 return (WINDOW_COPY_CMD_NOTHING);
1686 }
1687
1688 static enum window_copy_cmd_action
1689 window_copy_cmd_next_word_end(struct window_copy_cmd_state *cs)
1690 {
1691 struct window_mode_entry *wme = cs->wme;
1692 u_int np = wme->prefix;
1693 const char *separators;
1694
1695 separators = options_get_string(cs->s->options, "word-separators");
1696
1697 for (; np != 0; np--)
1698 window_copy_cursor_next_word_end(wme, separators, 0);
1699 return (WINDOW_COPY_CMD_NOTHING);
1700 }
1701
1702 static enum window_copy_cmd_action
1703 window_copy_cmd_other_end(struct window_copy_cmd_state *cs)
1704 {
1705 struct window_mode_entry *wme = cs->wme;
1706 u_int np = wme->prefix;
1707 struct window_copy_mode_data *data = wme->data;
1708
1709 data->selflag = SEL_CHAR;
1710 if ((np % 2) != 0)
1711 window_copy_other_end(wme);
1712 return (WINDOW_COPY_CMD_NOTHING);
1713 }
1714
1715 static enum window_copy_cmd_action
1716 window_copy_cmd_page_down(struct window_copy_cmd_state *cs)
1717 {
1718 struct window_mode_entry *wme = cs->wme;
1719 struct window_copy_mode_data *data = wme->data;
1720 u_int np = wme->prefix;
1721
1722 for (; np != 0; np--) {
1723 if (window_copy_pagedown(wme, 0, data->scroll_exit))
1724 return (WINDOW_COPY_CMD_CANCEL);
1725 }
1726 return (WINDOW_COPY_CMD_NOTHING);
1727 }
1728
1729 static enum window_copy_cmd_action
1730 window_copy_cmd_page_down_and_cancel(struct window_copy_cmd_state *cs)
1731 {
1732 struct window_mode_entry *wme = cs->wme;
1733 u_int np = wme->prefix;
1734
1735 for (; np != 0; np--) {
1736 if (window_copy_pagedown(wme, 0, 1))
1737 return (WINDOW_COPY_CMD_CANCEL);
1738 }
1739 return (WINDOW_COPY_CMD_NOTHING);
1740 }
1741
1742 static enum window_copy_cmd_action
1743 window_copy_cmd_page_up(struct window_copy_cmd_state *cs)
1744 {
1745 struct window_mode_entry *wme = cs->wme;
1746 u_int np = wme->prefix;
1747
1748 for (; np != 0; np--)
1749 window_copy_pageup1(wme, 0);
1750 return (WINDOW_COPY_CMD_NOTHING);
1751 }
1752
1753 static enum window_copy_cmd_action
1754 window_copy_cmd_previous_paragraph(struct window_copy_cmd_state *cs)
1755 {
1756 struct window_mode_entry *wme = cs->wme;
1757 u_int np = wme->prefix;
1758
1759 for (; np != 0; np--)
1760 window_copy_previous_paragraph(wme);
1761 return (WINDOW_COPY_CMD_NOTHING);
1762 }
1763
1764 static enum window_copy_cmd_action
1765 window_copy_cmd_previous_space(struct window_copy_cmd_state *cs)
1766 {
1767 struct window_mode_entry *wme = cs->wme;
1768 u_int np = wme->prefix;
1769
1770 for (; np != 0; np--)
1771 window_copy_cursor_previous_word(wme, "", 1);
1772 return (WINDOW_COPY_CMD_NOTHING);
1773 }
1774
1775 static enum window_copy_cmd_action
1776 window_copy_cmd_previous_word(struct window_copy_cmd_state *cs)
1777 {
1778 struct window_mode_entry *wme = cs->wme;
1779 u_int np = wme->prefix;
1780 const char *separators;
1781
1782 separators = options_get_string(cs->s->options, "word-separators");
1783
1784 for (; np != 0; np--)
1785 window_copy_cursor_previous_word(wme, separators, 1);
1786 return (WINDOW_COPY_CMD_NOTHING);
1787 }
1788
1789 static enum window_copy_cmd_action
1790 window_copy_cmd_rectangle_on(struct window_copy_cmd_state *cs)
1791 {
1792 struct window_mode_entry *wme = cs->wme;
1793 struct window_copy_mode_data *data = wme->data;
1794
1795 data->lineflag = LINE_SEL_NONE;
1796 window_copy_rectangle_set(wme, 1);
1797
1798 return (WINDOW_COPY_CMD_NOTHING);
1799 }
1800
1801 static enum window_copy_cmd_action
1802 window_copy_cmd_rectangle_off(struct window_copy_cmd_state *cs)
1803 {
1804 struct window_mode_entry *wme = cs->wme;
1805 struct window_copy_mode_data *data = wme->data;
1806
1807 data->lineflag = LINE_SEL_NONE;
1808 window_copy_rectangle_set(wme, 0);
1809
1810 return (WINDOW_COPY_CMD_NOTHING);
1811 }
1812
1813 static enum window_copy_cmd_action
1814 window_copy_cmd_rectangle_toggle(struct window_copy_cmd_state *cs)
1815 {
1816 struct window_mode_entry *wme = cs->wme;
1817 struct window_copy_mode_data *data = wme->data;
1818
1819 data->lineflag = LINE_SEL_NONE;
1820 window_copy_rectangle_set(wme, !data->rectflag);
1821
1822 return (WINDOW_COPY_CMD_NOTHING);
1823 }
1824
1825 static enum window_copy_cmd_action
1826 window_copy_cmd_scroll_down(struct window_copy_cmd_state *cs)
1827 {
1828 struct window_mode_entry *wme = cs->wme;
1829 struct window_copy_mode_data *data = wme->data;
1830 u_int np = wme->prefix;
1831
1832 for (; np != 0; np--)
1833 window_copy_cursor_down(wme, 1);
1834 if (data->scroll_exit && data->oy == 0)
1835 return (WINDOW_COPY_CMD_CANCEL);
1836 return (WINDOW_COPY_CMD_NOTHING);
1837 }
1838
1839 static enum window_copy_cmd_action
1840 window_copy_cmd_scroll_down_and_cancel(struct window_copy_cmd_state *cs)
1841 {
1842 struct window_mode_entry *wme = cs->wme;
1843 struct window_copy_mode_data *data = wme->data;
1844 u_int np = wme->prefix;
1845
1846 for (; np != 0; np--)
1847 window_copy_cursor_down(wme, 1);
1848 if (data->oy == 0)
1849 return (WINDOW_COPY_CMD_CANCEL);
1850 return (WINDOW_COPY_CMD_NOTHING);
1851 }
1852
1853 static enum window_copy_cmd_action
1854 window_copy_cmd_scroll_up(struct window_copy_cmd_state *cs)
1855 {
1856 struct window_mode_entry *wme = cs->wme;
1857 u_int np = wme->prefix;
1858
1859 for (; np != 0; np--)
1860 window_copy_cursor_up(wme, 1);
1861 return (WINDOW_COPY_CMD_NOTHING);
1862 }
1863
1864 static enum window_copy_cmd_action
1865 window_copy_cmd_search_again(struct window_copy_cmd_state *cs)
1866 {
1867 struct window_mode_entry *wme = cs->wme;
1868 struct window_copy_mode_data *data = wme->data;
1869 u_int np = wme->prefix;
1870
1871 if (data->searchtype == WINDOW_COPY_SEARCHUP) {
1872 for (; np != 0; np--)
1873 window_copy_search_up(wme, data->searchregex);
1874 } else if (data->searchtype == WINDOW_COPY_SEARCHDOWN) {
1875 for (; np != 0; np--)
1876 window_copy_search_down(wme, data->searchregex);
1877 }
1878 return (WINDOW_COPY_CMD_NOTHING);
1879 }
1880
1881 static enum window_copy_cmd_action
1882 window_copy_cmd_search_reverse(struct window_copy_cmd_state *cs)
1883 {
1884 struct window_mode_entry *wme = cs->wme;
1885 struct window_copy_mode_data *data = wme->data;
1886 u_int np = wme->prefix;
1887
1888 if (data->searchtype == WINDOW_COPY_SEARCHUP) {
1889 for (; np != 0; np--)
1890 window_copy_search_down(wme, data->searchregex);
1891 } else if (data->searchtype == WINDOW_COPY_SEARCHDOWN) {
1892 for (; np != 0; np--)
1893 window_copy_search_up(wme, data->searchregex);
1894 }
1895 return (WINDOW_COPY_CMD_NOTHING);
1896 }
1897
1898 static enum window_copy_cmd_action
1899 window_copy_cmd_select_line(struct window_copy_cmd_state *cs)
1900 {
1901 struct window_mode_entry *wme = cs->wme;
1902 struct window_copy_mode_data *data = wme->data;
1903 u_int np = wme->prefix;
1904
1905 data->lineflag = LINE_SEL_LEFT_RIGHT;
1906 data->rectflag = 0;
1907 data->selflag = SEL_LINE;
1908 data->dx = data->cx;
1909 data->dy = screen_hsize(data->backing) + data->cy - data->oy;
1910
1911 window_copy_cursor_start_of_line(wme);
1912 data->selrx = data->cx;
1913 data->selry = screen_hsize(data->backing) + data->cy - data->oy;
1914 data->endselry = data->selry;
1915 window_copy_start_selection(wme);
1916 window_copy_cursor_end_of_line(wme);
1917 data->endselry = screen_hsize(data->backing) + data->cy - data->oy;
1918 data->endselrx = window_copy_find_length(wme, data->endselry);
1919 for (; np > 1; np--) {
1920 window_copy_cursor_down(wme, 0);
1921 window_copy_cursor_end_of_line(wme);
1922 }
1923
1924 return (WINDOW_COPY_CMD_REDRAW);
1925 }
1926
1927 static enum window_copy_cmd_action
1928 window_copy_cmd_select_word(struct window_copy_cmd_state *cs)
1929 {
1930 struct window_mode_entry *wme = cs->wme;
1931 struct options *session_options = cs->s->options;
1932 struct window_copy_mode_data *data = wme->data;
1933 u_int px, py, nextx, nexty;
1934
1935 data->lineflag = LINE_SEL_LEFT_RIGHT;
1936 data->rectflag = 0;
1937 data->selflag = SEL_WORD;
1938 data->dx = data->cx;
1939 data->dy = screen_hsize(data->backing) + data->cy - data->oy;
1940
1941 data->separators = options_get_string(session_options,
1942 "word-separators");
1943 window_copy_cursor_previous_word(wme, data->separators, 0);
1944 px = data->cx;
1945 py = screen_hsize(data->backing) + data->cy - data->oy;
1946 data->selrx = px;
1947 data->selry = py;
1948 window_copy_start_selection(wme);
1949
1950 /* Handle single character words. */
1951 nextx = px + 1;
1952 nexty = py;
1953 if (grid_get_line(data->backing->grid, nexty)->flags &
1954 GRID_LINE_WRAPPED && nextx > screen_size_x(data->backing) - 1) {
1955 nextx = 0;
1956 nexty++;
1957 }
1958 if (px >= window_copy_find_length(wme, py) ||
1959 !window_copy_in_set(wme, nextx, nexty, WHITESPACE))
1960 window_copy_cursor_next_word_end(wme, data->separators, 1);
1961 else {
1962 window_copy_update_cursor(wme, px, data->cy);
1963 if (window_copy_update_selection(wme, 1, 1))
1964 window_copy_redraw_lines(wme, data->cy, 1);
1965 }
1966 data->endselrx = data->cx;
1967 data->endselry = screen_hsize(data->backing) + data->cy - data->oy;
1968 if (data->dy > data->endselry) {
1969 data->dy = data->endselry;
1970 data->dx = data->endselrx;
1971 } else if (data->dx > data->endselrx)
1972 data->dx = data->endselrx;
1973
1974 return (WINDOW_COPY_CMD_REDRAW);
1975 }
1976
1977 static enum window_copy_cmd_action
1978 window_copy_cmd_set_mark(struct window_copy_cmd_state *cs)
1979 {
1980 struct window_copy_mode_data *data = cs->wme->data;
1981
1982 data->mx = data->cx;
1983 data->my = screen_hsize(data->backing) + data->cy - data->oy;
1984 data->showmark = 1;
1985 return (WINDOW_COPY_CMD_REDRAW);
1986 }
1987
1988 static enum window_copy_cmd_action
1989 window_copy_cmd_start_of_line(struct window_copy_cmd_state *cs)
1990 {
1991 struct window_mode_entry *wme = cs->wme;
1992
1993 window_copy_cursor_start_of_line(wme);
1994 return (WINDOW_COPY_CMD_NOTHING);
1995 }
1996
1997 static enum window_copy_cmd_action
1998 window_copy_cmd_top_line(struct window_copy_cmd_state *cs)
1999 {
2000 struct window_mode_entry *wme = cs->wme;
2001 struct window_copy_mode_data *data = wme->data;
2002
2003 data->cx = 0;
2004 data->cy = 0;
2005
2006 window_copy_update_selection(wme, 1, 0);
2007 return (WINDOW_COPY_CMD_REDRAW);
2008 }
2009
2010 static enum window_copy_cmd_action
2011 window_copy_cmd_copy_pipe_no_clear(struct window_copy_cmd_state *cs)
2012 {
2013 struct window_mode_entry *wme = cs->wme;
2014 struct client *c = cs->c;
2015 struct session *s = cs->s;
2016 struct winlink *wl = cs->wl;
2017 struct window_pane *wp = wme->wp;
2018 char *command = NULL, *prefix = NULL;
2019 const char *arg1 = args_string(cs->args, 1);
2020 const char *arg2 = args_string(cs->args, 2);
2021
2022 if (arg2 != NULL)
2023 prefix = format_single(NULL, arg2, c, s, wl, wp);
2024
2025 if (s != NULL && arg1 != NULL && *arg1 != '\0')
2026 command = format_single(NULL, arg1, c, s, wl, wp);
2027 window_copy_copy_pipe(wme, s, prefix, command);
2028 free(command);
2029
2030 free(prefix);
2031 return (WINDOW_COPY_CMD_NOTHING);
2032 }
2033
2034 static enum window_copy_cmd_action
2035 window_copy_cmd_copy_pipe(struct window_copy_cmd_state *cs)
2036 {
2037 struct window_mode_entry *wme = cs->wme;
2038
2039 window_copy_cmd_copy_pipe_no_clear(cs);
2040 window_copy_clear_selection(wme);
2041 return (WINDOW_COPY_CMD_REDRAW);
2042 }
2043
2044 static enum window_copy_cmd_action
2045 window_copy_cmd_copy_pipe_and_cancel(struct window_copy_cmd_state *cs)
2046 {
2047 struct window_mode_entry *wme = cs->wme;
2048
2049 window_copy_cmd_copy_pipe_no_clear(cs);
2050 window_copy_clear_selection(wme);
2051 return (WINDOW_COPY_CMD_CANCEL);
2052 }
2053
2054 static enum window_copy_cmd_action
2055 window_copy_cmd_pipe_no_clear(struct window_copy_cmd_state *cs)
2056 {
2057 struct window_mode_entry *wme = cs->wme;
2058 struct client *c = cs->c;
2059 struct session *s = cs->s;
2060 struct winlink *wl = cs->wl;
2061 struct window_pane *wp = wme->wp;
2062 char *command = NULL;
2063 const char *arg1 = args_string(cs->args, 1);
2064
2065 if (s != NULL && arg1 != NULL && *arg1 != '\0')
2066 command = format_single(NULL, arg1, c, s, wl, wp);
2067 window_copy_pipe(wme, s, command);
2068 free(command);
2069
2070 return (WINDOW_COPY_CMD_NOTHING);
2071 }
2072
2073 static enum window_copy_cmd_action
2074 window_copy_cmd_pipe(struct window_copy_cmd_state *cs)
2075 {
2076 struct window_mode_entry *wme = cs->wme;
2077
2078 window_copy_cmd_pipe_no_clear(cs);
2079 window_copy_clear_selection(wme);
2080 return (WINDOW_COPY_CMD_REDRAW);
2081 }
2082
2083 static enum window_copy_cmd_action
2084 window_copy_cmd_pipe_and_cancel(struct window_copy_cmd_state *cs)
2085 {
2086 struct window_mode_entry *wme = cs->wme;
2087
2088 window_copy_cmd_pipe_no_clear(cs);
2089 window_copy_clear_selection(wme);
2090 return (WINDOW_COPY_CMD_CANCEL);
2091 }
2092
2093 static enum window_copy_cmd_action
2094 window_copy_cmd_goto_line(struct window_copy_cmd_state *cs)
2095 {
2096 struct window_mode_entry *wme = cs->wme;
2097 const char *arg1 = args_string(cs->args, 1);
2098
2099 if (*arg1 != '\0')
2100 window_copy_goto_line(wme, arg1);
2101 return (WINDOW_COPY_CMD_NOTHING);
2102 }
2103
2104 static enum window_copy_cmd_action
2105 window_copy_cmd_jump_backward(struct window_copy_cmd_state *cs)
2106 {
2107 struct window_mode_entry *wme = cs->wme;
2108 struct window_copy_mode_data *data = wme->data;
2109 u_int np = wme->prefix;
2110 const char *arg1 = args_string(cs->args, 1);
2111
2112 if (*arg1 != '\0') {
2113 data->jumptype = WINDOW_COPY_JUMPBACKWARD;
2114 free(data->jumpchar);
2115 data->jumpchar = utf8_fromcstr(arg1);
2116 for (; np != 0; np--)
2117 window_copy_cursor_jump_back(wme);
2118 }
2119 return (WINDOW_COPY_CMD_NOTHING);
2120 }
2121
2122 static enum window_copy_cmd_action
2123 window_copy_cmd_jump_forward(struct window_copy_cmd_state *cs)
2124 {
2125 struct window_mode_entry *wme = cs->wme;
2126 struct window_copy_mode_data *data = wme->data;
2127 u_int np = wme->prefix;
2128 const char *arg1 = args_string(cs->args, 1);
2129
2130 if (*arg1 != '\0') {
2131 data->jumptype = WINDOW_COPY_JUMPFORWARD;
2132 free(data->jumpchar);
2133 data->jumpchar = utf8_fromcstr(arg1);
2134 for (; np != 0; np--)
2135 window_copy_cursor_jump(wme);
2136 }
2137 return (WINDOW_COPY_CMD_NOTHING);
2138 }
2139
2140 static enum window_copy_cmd_action
2141 window_copy_cmd_jump_to_backward(struct window_copy_cmd_state *cs)
2142 {
2143 struct window_mode_entry *wme = cs->wme;
2144 struct window_copy_mode_data *data = wme->data;
2145 u_int np = wme->prefix;
2146 const char *arg1 = args_string(cs->args, 1);
2147
2148 if (*arg1 != '\0') {
2149 data->jumptype = WINDOW_COPY_JUMPTOBACKWARD;
2150 free(data->jumpchar);
2151 data->jumpchar = utf8_fromcstr(arg1);
2152 for (; np != 0; np--)
2153 window_copy_cursor_jump_to_back(wme);
2154 }
2155 return (WINDOW_COPY_CMD_NOTHING);
2156 }
2157
2158 static enum window_copy_cmd_action
2159 window_copy_cmd_jump_to_forward(struct window_copy_cmd_state *cs)
2160 {
2161 struct window_mode_entry *wme = cs->wme;
2162 struct window_copy_mode_data *data = wme->data;
2163 u_int np = wme->prefix;
2164 const char *arg1 = args_string(cs->args, 1);
2165
2166 if (*arg1 != '\0') {
2167 data->jumptype = WINDOW_COPY_JUMPTOFORWARD;
2168 free(data->jumpchar);
2169 data->jumpchar = utf8_fromcstr(arg1);
2170 for (; np != 0; np--)
2171 window_copy_cursor_jump_to(wme);
2172 }
2173 return (WINDOW_COPY_CMD_NOTHING);
2174 }
2175
2176 static enum window_copy_cmd_action
2177 window_copy_cmd_jump_to_mark(struct window_copy_cmd_state *cs)
2178 {
2179 struct window_mode_entry *wme = cs->wme;
2180
2181 window_copy_jump_to_mark(wme);
2182 return (WINDOW_COPY_CMD_NOTHING);
2183 }
2184
2185 static enum window_copy_cmd_action
2186 window_copy_cmd_search_backward(struct window_copy_cmd_state *cs)
2187 {
2188 struct window_mode_entry *wme = cs->wme;
2189 struct window_copy_mode_data *data = wme->data;
2190 u_int np = wme->prefix;
2191
2192 if (!window_copy_expand_search_string(cs))
2193 return (WINDOW_COPY_CMD_NOTHING);
2194
2195 if (data->searchstr != NULL) {
2196 data->searchtype = WINDOW_COPY_SEARCHUP;
2197 data->searchregex = 1;
2198 data->timeout = 0;
2199 for (; np != 0; np--)
2200 window_copy_search_up(wme, 1);
2201 }
2202 return (WINDOW_COPY_CMD_NOTHING);
2203 }
2204
2205 static enum window_copy_cmd_action
2206 window_copy_cmd_search_backward_text(struct window_copy_cmd_state *cs)
2207 {
2208 struct window_mode_entry *wme = cs->wme;
2209 struct window_copy_mode_data *data = wme->data;
2210 u_int np = wme->prefix;
2211
2212 if (!window_copy_expand_search_string(cs))
2213 return (WINDOW_COPY_CMD_NOTHING);
2214
2215 if (data->searchstr != NULL) {
2216 data->searchtype = WINDOW_COPY_SEARCHUP;
2217 data->searchregex = 0;
2218 data->timeout = 0;
2219 for (; np != 0; np--)
2220 window_copy_search_up(wme, 0);
2221 }
2222 return (WINDOW_COPY_CMD_NOTHING);
2223 }
2224
2225 static enum window_copy_cmd_action
2226 window_copy_cmd_search_forward(struct window_copy_cmd_state *cs)
2227 {
2228 struct window_mode_entry *wme = cs->wme;
2229 struct window_copy_mode_data *data = wme->data;
2230 u_int np = wme->prefix;
2231
2232 if (!window_copy_expand_search_string(cs))
2233 return (WINDOW_COPY_CMD_NOTHING);
2234
2235 if (data->searchstr != NULL) {
2236 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2237 data->searchregex = 1;
2238 data->timeout = 0;
2239 for (; np != 0; np--)
2240 window_copy_search_down(wme, 1);
2241 }
2242 return (WINDOW_COPY_CMD_NOTHING);
2243 }
2244
2245 static enum window_copy_cmd_action
2246 window_copy_cmd_search_forward_text(struct window_copy_cmd_state *cs)
2247 {
2248 struct window_mode_entry *wme = cs->wme;
2249 struct window_copy_mode_data *data = wme->data;
2250 u_int np = wme->prefix;
2251
2252 if (!window_copy_expand_search_string(cs))
2253 return (WINDOW_COPY_CMD_NOTHING);
2254
2255 if (data->searchstr != NULL) {
2256 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2257 data->searchregex = 0;
2258 data->timeout = 0;
2259 for (; np != 0; np--)
2260 window_copy_search_down(wme, 0);
2261 }
2262 return (WINDOW_COPY_CMD_NOTHING);
2263 }
2264
2265 static enum window_copy_cmd_action
2266 window_copy_cmd_search_backward_incremental(struct window_copy_cmd_state *cs)
2267 {
2268 struct window_mode_entry *wme = cs->wme;
2269 struct window_copy_mode_data *data = wme->data;
2270 const char *arg1 = args_string(cs->args, 1);
2271 const char *ss = data->searchstr;
2272 char prefix;
2273 enum window_copy_cmd_action action = WINDOW_COPY_CMD_NOTHING;
2274
2275 data->timeout = 0;
2276
2277 log_debug("%s: %s", __func__, arg1);
2278
2279 prefix = *arg1++;
2280 if (data->searchx == -1 || data->searchy == -1) {
2281 data->searchx = data->cx;
2282 data->searchy = data->cy;
2283 data->searcho = data->oy;
2284 } else if (ss != NULL && strcmp(arg1, ss) != 0) {
2285 data->cx = data->searchx;
2286 data->cy = data->searchy;
2287 data->oy = data->searcho;
2288 action = WINDOW_COPY_CMD_REDRAW;
2289 }
2290 if (*arg1 == '\0') {
2291 window_copy_clear_marks(wme);
2292 return (WINDOW_COPY_CMD_REDRAW);
2293 }
2294 switch (prefix) {
2295 case '=':
2296 case '-':
2297 data->searchtype = WINDOW_COPY_SEARCHUP;
2298 data->searchregex = 0;
2299 free(data->searchstr);
2300 data->searchstr = xstrdup(arg1);
2301 if (!window_copy_search_up(wme, 0)) {
2302 window_copy_clear_marks(wme);
2303 return (WINDOW_COPY_CMD_REDRAW);
2304 }
2305 break;
2306 case '+':
2307 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2308 data->searchregex = 0;
2309 free(data->searchstr);
2310 data->searchstr = xstrdup(arg1);
2311 if (!window_copy_search_down(wme, 0)) {
2312 window_copy_clear_marks(wme);
2313 return (WINDOW_COPY_CMD_REDRAW);
2314 }
2315 break;
2316 }
2317 return (action);
2318 }
2319
2320 static enum window_copy_cmd_action
2321 window_copy_cmd_search_forward_incremental(struct window_copy_cmd_state *cs)
2322 {
2323 struct window_mode_entry *wme = cs->wme;
2324 struct window_copy_mode_data *data = wme->data;
2325 const char *arg1 = args_string(cs->args, 1);
2326 const char *ss = data->searchstr;
2327 char prefix;
2328 enum window_copy_cmd_action action = WINDOW_COPY_CMD_NOTHING;
2329
2330 data->timeout = 0;
2331
2332 log_debug("%s: %s", __func__, arg1);
2333
2334 prefix = *arg1++;
2335 if (data->searchx == -1 || data->searchy == -1) {
2336 data->searchx = data->cx;
2337 data->searchy = data->cy;
2338 data->searcho = data->oy;
2339 } else if (ss != NULL && strcmp(arg1, ss) != 0) {
2340 data->cx = data->searchx;
2341 data->cy = data->searchy;
2342 data->oy = data->searcho;
2343 action = WINDOW_COPY_CMD_REDRAW;
2344 }
2345 if (*arg1 == '\0') {
2346 window_copy_clear_marks(wme);
2347 return (WINDOW_COPY_CMD_REDRAW);
2348 }
2349 switch (prefix) {
2350 case '=':
2351 case '+':
2352 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2353 data->searchregex = 0;
2354 free(data->searchstr);
2355 data->searchstr = xstrdup(arg1);
2356 if (!window_copy_search_down(wme, 0)) {
2357 window_copy_clear_marks(wme);
2358 return (WINDOW_COPY_CMD_REDRAW);
2359 }
2360 break;
2361 case '-':
2362 data->searchtype = WINDOW_COPY_SEARCHUP;
2363 data->searchregex = 0;
2364 free(data->searchstr);
2365 data->searchstr = xstrdup(arg1);
2366 if (!window_copy_search_up(wme, 0)) {
2367 window_copy_clear_marks(wme);
2368 return (WINDOW_COPY_CMD_REDRAW);
2369 }
2370 }
2371 return (action);
2372 }
2373
2374 static enum window_copy_cmd_action
2375 window_copy_cmd_refresh_from_pane(struct window_copy_cmd_state *cs)
2376 {
2377 struct window_mode_entry *wme = cs->wme;
2378 struct window_pane *wp = wme->swp;
2379 struct window_copy_mode_data *data = wme->data;
2380
2381 if (data->viewmode)
2382 return (WINDOW_COPY_CMD_NOTHING);
2383
2384 screen_free(data->backing);
2385 free(data->backing);
2386 data->backing = window_copy_clone_screen(&wp->base, &data->screen, NULL, NULL, wme->swp != wme->wp);
2387
2388 window_copy_size_changed(wme);
2389 return (WINDOW_COPY_CMD_REDRAW);
2390 }
2391
2392 static const struct {
2393 const char *command;
2394 u_int minargs;
2395 u_int maxargs;
2396 enum window_copy_cmd_clear clear;
2397 enum window_copy_cmd_action (*f)(struct window_copy_cmd_state *);
2398 } window_copy_cmd_table[] = {
2399 { .command = "append-selection",
2400 .minargs = 0,
2401 .maxargs = 0,
2402 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2403 .f = window_copy_cmd_append_selection
2404 },
2405 { .command = "append-selection-and-cancel",
2406 .minargs = 0,
2407 .maxargs = 0,
2408 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2409 .f = window_copy_cmd_append_selection_and_cancel
2410 },
2411 { .command = "back-to-indentation",
2412 .minargs = 0,
2413 .maxargs = 0,
2414 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2415 .f = window_copy_cmd_back_to_indentation
2416 },
2417 { .command = "begin-selection",
2418 .minargs = 0,
2419 .maxargs = 0,
2420 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2421 .f = window_copy_cmd_begin_selection
2422 },
2423 { .command = "bottom-line",
2424 .minargs = 0,
2425 .maxargs = 0,
2426 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2427 .f = window_copy_cmd_bottom_line
2428 },
2429 { .command = "cancel",
2430 .minargs = 0,
2431 .maxargs = 0,
2432 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2433 .f = window_copy_cmd_cancel
2434 },
2435 { .command = "clear-selection",
2436 .minargs = 0,
2437 .maxargs = 0,
2438 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2439 .f = window_copy_cmd_clear_selection
2440 },
2441 { .command = "copy-end-of-line",
2442 .minargs = 0,
2443 .maxargs = 1,
2444 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2445 .f = window_copy_cmd_copy_end_of_line
2446 },
2447 { .command = "copy-end-of-line-and-cancel",
2448 .minargs = 0,
2449 .maxargs = 1,
2450 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2451 .f = window_copy_cmd_copy_end_of_line_and_cancel
2452 },
2453 { .command = "copy-pipe-end-of-line",
2454 .minargs = 0,
2455 .maxargs = 2,
2456 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2457 .f = window_copy_cmd_copy_pipe_end_of_line
2458 },
2459 { .command = "copy-pipe-end-of-line-and-cancel",
2460 .minargs = 0,
2461 .maxargs = 2,
2462 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2463 .f = window_copy_cmd_copy_pipe_end_of_line_and_cancel
2464 },
2465 { .command = "copy-line",
2466 .minargs = 0,
2467 .maxargs = 1,
2468 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2469 .f = window_copy_cmd_copy_line
2470 },
2471 { .command = "copy-line-and-cancel",
2472 .minargs = 0,
2473 .maxargs = 1,
2474 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2475 .f = window_copy_cmd_copy_line_and_cancel
2476 },
2477 { .command = "copy-pipe-line",
2478 .minargs = 0,
2479 .maxargs = 2,
2480 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2481 .f = window_copy_cmd_copy_pipe_line
2482 },
2483 { .command = "copy-pipe-line-and-cancel",
2484 .minargs = 0,
2485 .maxargs = 2,
2486 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2487 .f = window_copy_cmd_copy_pipe_line_and_cancel
2488 },
2489 { .command = "copy-pipe-no-clear",
2490 .minargs = 0,
2491 .maxargs = 2,
2492 .clear = WINDOW_COPY_CMD_CLEAR_NEVER,
2493 .f = window_copy_cmd_copy_pipe_no_clear
2494 },
2495 { .command = "copy-pipe",
2496 .minargs = 0,
2497 .maxargs = 2,
2498 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2499 .f = window_copy_cmd_copy_pipe
2500 },
2501 { .command = "copy-pipe-and-cancel",
2502 .minargs = 0,
2503 .maxargs = 2,
2504 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2505 .f = window_copy_cmd_copy_pipe_and_cancel
2506 },
2507 { .command = "copy-selection-no-clear",
2508 .minargs = 0,
2509 .maxargs = 1,
2510 .clear = WINDOW_COPY_CMD_CLEAR_NEVER,
2511 .f = window_copy_cmd_copy_selection_no_clear
2512 },
2513 { .command = "copy-selection",
2514 .minargs = 0,
2515 .maxargs = 1,
2516 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2517 .f = window_copy_cmd_copy_selection
2518 },
2519 { .command = "copy-selection-and-cancel",
2520 .minargs = 0,
2521 .maxargs = 1,
2522 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2523 .f = window_copy_cmd_copy_selection_and_cancel
2524 },
2525 { .command = "cursor-down",
2526 .minargs = 0,
2527 .maxargs = 0,
2528 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2529 .f = window_copy_cmd_cursor_down
2530 },
2531 { .command = "cursor-down-and-cancel",
2532 .minargs = 0,
2533 .maxargs = 0,
2534 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2535 .f = window_copy_cmd_cursor_down_and_cancel
2536 },
2537 { .command = "cursor-left",
2538 .minargs = 0,
2539 .maxargs = 0,
2540 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2541 .f = window_copy_cmd_cursor_left
2542 },
2543 { .command = "cursor-right",
2544 .minargs = 0,
2545 .maxargs = 0,
2546 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2547 .f = window_copy_cmd_cursor_right
2548 },
2549 { .command = "cursor-up",
2550 .minargs = 0,
2551 .maxargs = 0,
2552 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2553 .f = window_copy_cmd_cursor_up
2554 },
2555 { .command = "end-of-line",
2556 .minargs = 0,
2557 .maxargs = 0,
2558 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2559 .f = window_copy_cmd_end_of_line
2560 },
2561 { .command = "goto-line",
2562 .minargs = 1,
2563 .maxargs = 1,
2564 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2565 .f = window_copy_cmd_goto_line
2566 },
2567 { .command = "halfpage-down",
2568 .minargs = 0,
2569 .maxargs = 0,
2570 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2571 .f = window_copy_cmd_halfpage_down
2572 },
2573 { .command = "halfpage-down-and-cancel",
2574 .minargs = 0,
2575 .maxargs = 0,
2576 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2577 .f = window_copy_cmd_halfpage_down_and_cancel
2578 },
2579 { .command = "halfpage-up",
2580 .minargs = 0,
2581 .maxargs = 0,
2582 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2583 .f = window_copy_cmd_halfpage_up
2584 },
2585 { .command = "history-bottom",
2586 .minargs = 0,
2587 .maxargs = 0,
2588 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2589 .f = window_copy_cmd_history_bottom
2590 },
2591 { .command = "history-top",
2592 .minargs = 0,
2593 .maxargs = 0,
2594 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2595 .f = window_copy_cmd_history_top
2596 },
2597 { .command = "jump-again",
2598 .minargs = 0,
2599 .maxargs = 0,
2600 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2601 .f = window_copy_cmd_jump_again
2602 },
2603 { .command = "jump-backward",
2604 .minargs = 1,
2605 .maxargs = 1,
2606 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2607 .f = window_copy_cmd_jump_backward
2608 },
2609 { .command = "jump-forward",
2610 .minargs = 1,
2611 .maxargs = 1,
2612 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2613 .f = window_copy_cmd_jump_forward
2614 },
2615 { .command = "jump-reverse",
2616 .minargs = 0,
2617 .maxargs = 0,
2618 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2619 .f = window_copy_cmd_jump_reverse
2620 },
2621 { .command = "jump-to-backward",
2622 .minargs = 1,
2623 .maxargs = 1,
2624 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2625 .f = window_copy_cmd_jump_to_backward
2626 },
2627 { .command = "jump-to-forward",
2628 .minargs = 1,
2629 .maxargs = 1,
2630 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2631 .f = window_copy_cmd_jump_to_forward
2632 },
2633 { .command = "jump-to-mark",
2634 .minargs = 0,
2635 .maxargs = 0,
2636 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2637 .f = window_copy_cmd_jump_to_mark
2638 },
2639 { .command = "middle-line",
2640 .minargs = 0,
2641 .maxargs = 0,
2642 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2643 .f = window_copy_cmd_middle_line
2644 },
2645 { .command = "next-matching-bracket",
2646 .minargs = 0,
2647 .maxargs = 0,
2648 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2649 .f = window_copy_cmd_next_matching_bracket
2650 },
2651 { .command = "next-paragraph",
2652 .minargs = 0,
2653 .maxargs = 0,
2654 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2655 .f = window_copy_cmd_next_paragraph
2656 },
2657 { .command = "next-space",
2658 .minargs = 0,
2659 .maxargs = 0,
2660 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2661 .f = window_copy_cmd_next_space
2662 },
2663 { .command = "next-space-end",
2664 .minargs = 0,
2665 .maxargs = 0,
2666 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2667 .f = window_copy_cmd_next_space_end
2668 },
2669 { .command = "next-word",
2670 .minargs = 0,
2671 .maxargs = 0,
2672 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2673 .f = window_copy_cmd_next_word
2674 },
2675 { .command = "next-word-end",
2676 .minargs = 0,
2677 .maxargs = 0,
2678 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2679 .f = window_copy_cmd_next_word_end
2680 },
2681 { .command = "other-end",
2682 .minargs = 0,
2683 .maxargs = 0,
2684 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2685 .f = window_copy_cmd_other_end
2686 },
2687 { .command = "page-down",
2688 .minargs = 0,
2689 .maxargs = 0,
2690 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2691 .f = window_copy_cmd_page_down
2692 },
2693 { .command = "page-down-and-cancel",
2694 .minargs = 0,
2695 .maxargs = 0,
2696 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2697 .f = window_copy_cmd_page_down_and_cancel
2698 },
2699 { .command = "page-up",
2700 .minargs = 0,
2701 .maxargs = 0,
2702 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2703 .f = window_copy_cmd_page_up
2704 },
2705 { .command = "pipe-no-clear",
2706 .minargs = 0,
2707 .maxargs = 1,
2708 .clear = WINDOW_COPY_CMD_CLEAR_NEVER,
2709 .f = window_copy_cmd_pipe_no_clear
2710 },
2711 { .command = "pipe",
2712 .minargs = 0,
2713 .maxargs = 1,
2714 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2715 .f = window_copy_cmd_pipe
2716 },
2717 { .command = "pipe-and-cancel",
2718 .minargs = 0,
2719 .maxargs = 1,
2720 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2721 .f = window_copy_cmd_pipe_and_cancel
2722 },
2723 { .command = "previous-matching-bracket",
2724 .minargs = 0,
2725 .maxargs = 0,
2726 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2727 .f = window_copy_cmd_previous_matching_bracket
2728 },
2729 { .command = "previous-paragraph",
2730 .minargs = 0,
2731 .maxargs = 0,
2732 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2733 .f = window_copy_cmd_previous_paragraph
2734 },
2735 { .command = "previous-space",
2736 .minargs = 0,
2737 .maxargs = 0,
2738 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2739 .f = window_copy_cmd_previous_space
2740 },
2741 { .command = "previous-word",
2742 .minargs = 0,
2743 .maxargs = 0,
2744 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2745 .f = window_copy_cmd_previous_word
2746 },
2747 { .command = "rectangle-on",
2748 .minargs = 0,
2749 .maxargs = 0,
2750 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2751 .f = window_copy_cmd_rectangle_on
2752 },
2753 { .command = "rectangle-off",
2754 .minargs = 0,
2755 .maxargs = 0,
2756 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2757 .f = window_copy_cmd_rectangle_off
2758 },
2759 { .command = "rectangle-toggle",
2760 .minargs = 0,
2761 .maxargs = 0,
2762 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2763 .f = window_copy_cmd_rectangle_toggle
2764 },
2765 { .command = "refresh-from-pane",
2766 .minargs = 0,
2767 .maxargs = 0,
2768 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2769 .f = window_copy_cmd_refresh_from_pane
2770 },
2771 { .command = "scroll-down",
2772 .minargs = 0,
2773 .maxargs = 0,
2774 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2775 .f = window_copy_cmd_scroll_down
2776 },
2777 { .command = "scroll-down-and-cancel",
2778 .minargs = 0,
2779 .maxargs = 0,
2780 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2781 .f = window_copy_cmd_scroll_down_and_cancel
2782 },
2783 { .command = "scroll-up",
2784 .minargs = 0,
2785 .maxargs = 0,
2786 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2787 .f = window_copy_cmd_scroll_up
2788 },
2789 { .command = "search-again",
2790 .minargs = 0,
2791 .maxargs = 0,
2792 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2793 .f = window_copy_cmd_search_again
2794 },
2795 { .command = "search-backward",
2796 .minargs = 0,
2797 .maxargs = 1,
2798 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2799 .f = window_copy_cmd_search_backward
2800 },
2801 { .command = "search-backward-text",
2802 .minargs = 0,
2803 .maxargs = 1,
2804 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2805 .f = window_copy_cmd_search_backward_text
2806 },
2807 { .command = "search-backward-incremental",
2808 .minargs = 1,
2809 .maxargs = 1,
2810 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2811 .f = window_copy_cmd_search_backward_incremental
2812 },
2813 { .command = "search-forward",
2814 .minargs = 0,
2815 .maxargs = 1,
2816 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2817 .f = window_copy_cmd_search_forward
2818 },
2819 { .command = "search-forward-text",
2820 .minargs = 0,
2821 .maxargs = 1,
2822 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2823 .f = window_copy_cmd_search_forward_text
2824 },
2825 { .command = "search-forward-incremental",
2826 .minargs = 1,
2827 .maxargs = 1,
2828 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2829 .f = window_copy_cmd_search_forward_incremental
2830 },
2831 { .command = "search-reverse",
2832 .minargs = 0,
2833 .maxargs = 0,
2834 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2835 .f = window_copy_cmd_search_reverse
2836 },
2837 { .command = "select-line",
2838 .minargs = 0,
2839 .maxargs = 0,
2840 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2841 .f = window_copy_cmd_select_line
2842 },
2843 { .command = "select-word",
2844 .minargs = 0,
2845 .maxargs = 0,
2846 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2847 .f = window_copy_cmd_select_word
2848 },
2849 { .command = "set-mark",
2850 .minargs = 0,
2851 .maxargs = 0,
2852 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2853 .f = window_copy_cmd_set_mark
2854 },
2855 { .command = "start-of-line",
2856 .minargs = 0,
2857 .maxargs = 0,
2858 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2859 .f = window_copy_cmd_start_of_line
2860 },
2861 { .command = "stop-selection",
2862 .minargs = 0,
2863 .maxargs = 0,
2864 .clear = WINDOW_COPY_CMD_CLEAR_ALWAYS,
2865 .f = window_copy_cmd_stop_selection
2866 },
2867 { .command = "toggle-position",
2868 .minargs = 0,
2869 .maxargs = 0,
2870 .clear = WINDOW_COPY_CMD_CLEAR_NEVER,
2871 .f = window_copy_cmd_toggle_position
2872 },
2873 { .command = "top-line",
2874 .minargs = 0,
2875 .maxargs = 0,
2876 .clear = WINDOW_COPY_CMD_CLEAR_EMACS_ONLY,
2877 .f = window_copy_cmd_top_line
2878 }
2879 };
2880
2881 static void
2882 window_copy_command(struct window_mode_entry *wme, struct client *c,
2883 struct session *s, struct winlink *wl, struct args *args,
2884 struct mouse_event *m)
2885 {
2886 struct window_copy_mode_data *data = wme->data;
2887 struct window_copy_cmd_state cs;
2888 enum window_copy_cmd_action action;
2889 enum window_copy_cmd_clear clear = WINDOW_COPY_CMD_CLEAR_NEVER;
2890 const char *command;
2891 u_int i, count = args_count(args);
2892 int keys;
2893
2894 if (count == 0)
2895 return;
2896 command = args_string(args, 0);
2897
2898 if (m != NULL && m->valid && !MOUSE_WHEEL(m->b))
2899 window_copy_move_mouse(m);
2900
2901 cs.wme = wme;
2902 cs.args = args;
2903 cs.m = m;
2904
2905 cs.c = c;
2906 cs.s = s;
2907 cs.wl = wl;
2908
2909 action = WINDOW_COPY_CMD_NOTHING;
2910 for (i = 0; i < nitems(window_copy_cmd_table); i++) {
2911 if (strcmp(window_copy_cmd_table[i].command, command) == 0) {
2912 if (count - 1 < window_copy_cmd_table[i].minargs ||
2913 count - 1 > window_copy_cmd_table[i].maxargs)
2914 break;
2915 clear = window_copy_cmd_table[i].clear;
2916 action = window_copy_cmd_table[i].f(&cs);
2917 break;
2918 }
2919 }
2920
2921 if (strncmp(command, "search-", 7) != 0 && data->searchmark != NULL) {
2922 keys = options_get_number(wme->wp->window->options, "mode-keys");
2923 if (clear == WINDOW_COPY_CMD_CLEAR_EMACS_ONLY &&
2924 keys == MODEKEY_VI)
2925 clear = WINDOW_COPY_CMD_CLEAR_NEVER;
2926 if (clear != WINDOW_COPY_CMD_CLEAR_NEVER) {
2927 window_copy_clear_marks(wme);
2928 data->searchx = data->searchy = -1;
2929 }
2930 if (action == WINDOW_COPY_CMD_NOTHING)
2931 action = WINDOW_COPY_CMD_REDRAW;
2932 }
2933 wme->prefix = 1;
2934
2935 if (action == WINDOW_COPY_CMD_CANCEL)
2936 window_pane_reset_mode(wme->wp);
2937 else if (action == WINDOW_COPY_CMD_REDRAW)
2938 window_copy_redraw_screen(wme);
2939 }
2940
2941 static void
2942 window_copy_scroll_to(struct window_mode_entry *wme, u_int px, u_int py,
2943 int no_redraw)
2944 {
2945 struct window_copy_mode_data *data = wme->data;
2946 struct grid *gd = data->backing->grid;
2947 u_int offset, gap;
2948
2949 data->cx = px;
2950
2951 if (py >= gd->hsize - data->oy && py < gd->hsize - data->oy + gd->sy)
2952 data->cy = py - (gd->hsize - data->oy);
2953 else {
2954 gap = gd->sy / 4;
2955 if (py < gd->sy) {
2956 offset = 0;
2957 data->cy = py;
2958 } else if (py > gd->hsize + gd->sy - gap) {
2959 offset = gd->hsize;
2960 data->cy = py - gd->hsize;
2961 } else {
2962 offset = py + gap - gd->sy;
2963 data->cy = py - offset;
2964 }
2965 data->oy = gd->hsize - offset;
2966 }
2967
2968 if (!no_redraw && data->searchmark != NULL && !data->timeout)
2969 window_copy_search_marks(wme, NULL, data->searchregex, 1);
2970 window_copy_update_selection(wme, 1, 0);
2971 if (!no_redraw)
2972 window_copy_redraw_screen(wme);
2973 }
2974
2975 static int
2976 window_copy_search_compare(struct grid *gd, u_int px, u_int py,
2977 struct grid *sgd, u_int spx, int cis)
2978 {
2979 struct grid_cell gc, sgc;
2980 const struct utf8_data *ud, *sud;
2981
2982 grid_get_cell(gd, px, py, &gc);
2983 ud = &gc.data;
2984 grid_get_cell(sgd, spx, 0, &sgc);
2985 sud = &sgc.data;
2986
2987 if (ud->size != sud->size || ud->width != sud->width)
2988 return (0);
2989
2990 if (cis && ud->size == 1)
2991 return (tolower(ud->data[0]) == sud->data[0]);
2992
2993 return (memcmp(ud->data, sud->data, ud->size) == 0);
2994 }
2995
2996 static int
2997 window_copy_search_lr(struct grid *gd, struct grid *sgd, u_int *ppx, u_int py,
2998 u_int first, u_int last, int cis)
2999 {
3000 u_int ax, bx, px, pywrap, endline;
3001 int matched;
3002 struct grid_line *gl;
3003
3004 endline = gd->hsize + gd->sy - 1;
3005 for (ax = first; ax < last; ax++) {
3006 for (bx = 0; bx < sgd->sx; bx++) {
3007 px = ax + bx;
3008 pywrap = py;
3009 /* Wrap line. */
3010 while (px >= gd->sx && pywrap < endline) {
3011 gl = grid_get_line(gd, pywrap);
3012 if (~gl->flags & GRID_LINE_WRAPPED)
3013 break;
3014 px -= gd->sx;
3015 pywrap++;
3016 }
3017 /* We have run off the end of the grid. */
3018 if (px >= gd->sx)
3019 break;
3020 matched = window_copy_search_compare(gd, px, pywrap,
3021 sgd, bx, cis);
3022 if (!matched)
3023 break;
3024 }
3025 if (bx == sgd->sx) {
3026 *ppx = ax;
3027 return (1);
3028 }
3029 }
3030 return (0);
3031 }
3032
3033 static int
3034 window_copy_search_rl(struct grid *gd,
3035 struct grid *sgd, u_int *ppx, u_int py, u_int first, u_int last, int cis)
3036 {
3037 u_int ax, bx, px, pywrap, endline;
3038 int matched;
3039 struct grid_line *gl;
3040
3041 endline = gd->hsize + gd->sy - 1;
3042 for (ax = last; ax > first; ax--) {
3043 for (bx = 0; bx < sgd->sx; bx++) {
3044 px = ax - 1 + bx;
3045 pywrap = py;
3046 /* Wrap line. */
3047 while (px >= gd->sx && pywrap < endline) {
3048 gl = grid_get_line(gd, pywrap);
3049 if (~gl->flags & GRID_LINE_WRAPPED)
3050 break;
3051 px -= gd->sx;
3052 pywrap++;
3053 }
3054 /* We have run off the end of the grid. */
3055 if (px >= gd->sx)
3056 break;
3057 matched = window_copy_search_compare(gd, px, pywrap,
3058 sgd, bx, cis);
3059 if (!matched)
3060 break;
3061 }
3062 if (bx == sgd->sx) {
3063 *ppx = ax - 1;
3064 return (1);
3065 }
3066 }
3067 return (0);
3068 }
3069
3070 static int
3071 window_copy_search_lr_regex(struct grid *gd, u_int *ppx, u_int *psx, u_int py,
3072 u_int first, u_int last, regex_t *reg)
3073 {
3074 int eflags = 0;
3075 u_int endline, foundx, foundy, len, pywrap, size = 1;
3076 char *buf;
3077 regmatch_t regmatch;
3078 struct grid_line *gl;
3079
3080 /*
3081 * This can happen during search if the last match was the last
3082 * character on a line.
3083 */
3084 if (first >= last)
3085 return (0);
3086
3087 /* Set flags for regex search. */
3088 if (first != 0)
3089 eflags |= REG_NOTBOL;
3090
3091 /* Need to look at the entire string. */
3092 buf = xmalloc(size);
3093 buf[0] = '\0';
3094 buf = window_copy_stringify(gd, py, first, gd->sx, buf, &size);
3095 len = gd->sx - first;
3096 endline = gd->hsize + gd->sy - 1;
3097 pywrap = py;
3098 while (buf != NULL && pywrap <= endline) {
3099 gl = grid_get_line(gd, pywrap);
3100 if (~gl->flags & GRID_LINE_WRAPPED)
3101 break;
3102 pywrap++;
3103 buf = window_copy_stringify(gd, pywrap, 0, gd->sx, buf, &size);
3104 len += gd->sx;
3105 }
3106
3107 if (regexec(reg, buf, 1, &regmatch, eflags) == 0 &&
3108 regmatch.rm_so != regmatch.rm_eo) {
3109 foundx = first;
3110 foundy = py;
3111 window_copy_cstrtocellpos(gd, len, &foundx, &foundy,
3112 buf + regmatch.rm_so);
3113 if (foundy == py && foundx < last) {
3114 *ppx = foundx;
3115 len -= foundx - first;
3116 window_copy_cstrtocellpos(gd, len, &foundx, &foundy,
3117 buf + regmatch.rm_eo);
3118 *psx = foundx;
3119 while (foundy > py) {
3120 *psx += gd->sx;
3121 foundy--;
3122 }
3123 *psx -= *ppx;
3124 free(buf);
3125 return (1);
3126 }
3127 }
3128
3129 free(buf);
3130 *ppx = 0;
3131 *psx = 0;
3132 return (0);
3133 }
3134
3135 static int
3136 window_copy_search_rl_regex(struct grid *gd, u_int *ppx, u_int *psx, u_int py,
3137 u_int first, u_int last, regex_t *reg)
3138 {
3139 int eflags = 0;
3140 u_int endline, len, pywrap, size = 1;
3141 char *buf;
3142 struct grid_line *gl;
3143
3144 /* Set flags for regex search. */
3145 if (first != 0)
3146 eflags |= REG_NOTBOL;
3147
3148 /* Need to look at the entire string. */
3149 buf = xmalloc(size);
3150 buf[0] = '\0';
3151 buf = window_copy_stringify(gd, py, first, gd->sx, buf, &size);
3152 len = gd->sx - first;
3153 endline = gd->hsize + gd->sy - 1;
3154 pywrap = py;
3155 while (buf != NULL && (pywrap <= endline)) {
3156 gl = grid_get_line(gd, pywrap);
3157 if (~gl->flags & GRID_LINE_WRAPPED)
3158 break;
3159 pywrap++;
3160 buf = window_copy_stringify(gd, pywrap, 0, gd->sx, buf, &size);
3161 len += gd->sx;
3162 }
3163
3164 if (window_copy_last_regex(gd, py, first, last, len, ppx, psx, buf,
3165 reg, eflags))
3166 {
3167 free(buf);
3168 return (1);
3169 }
3170
3171 free(buf);
3172 *ppx = 0;
3173 *psx = 0;
3174 return (0);
3175 }
3176
3177 static const char *
3178 window_copy_cellstring(const struct grid_line *gl, u_int px, size_t *size,
3179 int *allocated)
3180 {
3181 static struct utf8_data ud;
3182 struct grid_cell_entry *gce;
3183 char *copy;
3184
3185 if (px >= gl->cellsize) {
3186 *size = 1;
3187 *allocated = 0;
3188 return (" ");
3189 }
3190
3191 gce = &gl->celldata[px];
3192 if (gce->flags & GRID_FLAG_PADDING) {
3193 *size = 0;
3194 *allocated = 0;
3195 return (NULL);
3196 }
3197 if (~gce->flags & GRID_FLAG_EXTENDED) {
3198 *size = 1;
3199 *allocated = 0;
3200 return (&gce->data.data);
3201 }
3202
3203 utf8_to_data(gl->extddata[gce->offset].data, &ud);
3204 if (ud.size == 0) {
3205 *size = 0;
3206 *allocated = 0;
3207 return (NULL);
3208 }
3209 *size = ud.size;
3210 *allocated = 1;
3211
3212 copy = xmalloc(ud.size);
3213 memcpy(copy, ud.data, ud.size);
3214 return (copy);
3215 }
3216
3217 /* Find last match in given range. */
3218 static int
3219 window_copy_last_regex(struct grid *gd, u_int py, u_int first, u_int last,
3220 u_int len, u_int *ppx, u_int *psx, const char *buf, const regex_t *preg,
3221 int eflags)
3222 {
3223 u_int foundx, foundy, oldx, px = 0, savepx, savesx = 0;
3224 regmatch_t regmatch;
3225
3226 foundx = first;
3227 foundy = py;
3228 oldx = first;
3229 while (regexec(preg, buf + px, 1, &regmatch, eflags) == 0) {
3230 if (regmatch.rm_so == regmatch.rm_eo)
3231 break;
3232 window_copy_cstrtocellpos(gd, len, &foundx, &foundy,
3233 buf + px + regmatch.rm_so);
3234 if (foundy > py || foundx >= last)
3235 break;
3236 len -= foundx - oldx;
3237 savepx = foundx;
3238 window_copy_cstrtocellpos(gd, len, &foundx, &foundy,
3239 buf + px + regmatch.rm_eo);
3240 if (foundy > py || foundx >= last) {
3241 *ppx = savepx;
3242 *psx = foundx;
3243 while (foundy > py) {
3244 *psx += gd->sx;
3245 foundy--;
3246 }
3247 *psx -= *ppx;
3248 return (1);
3249 } else {
3250 savesx = foundx - savepx;
3251 len -= savesx;
3252 oldx = foundx;
3253 }
3254 px += regmatch.rm_eo;
3255 }
3256
3257 if (savesx > 0) {
3258 *ppx = savepx;
3259 *psx = savesx;
3260 return (1);
3261 } else {
3262 *ppx = 0;
3263 *psx = 0;
3264 return (0);
3265 }
3266 }
3267
3268 /* Stringify line and append to input buffer. Caller frees. */
3269 static char *
3270 window_copy_stringify(struct grid *gd, u_int py, u_int first, u_int last,
3271 char *buf, u_int *size)
3272 {
3273 u_int ax, bx, newsize = *size;
3274 const struct grid_line *gl;
3275 const char *d;
3276 size_t bufsize = 1024, dlen;
3277 int allocated;
3278
3279 while (bufsize < newsize)
3280 bufsize *= 2;
3281 buf = xrealloc(buf, bufsize);
3282
3283 gl = grid_peek_line(gd, py);
3284 bx = *size - 1;
3285 for (ax = first; ax < last; ax++) {
3286 d = window_copy_cellstring(gl, ax, &dlen, &allocated);
3287 newsize += dlen;
3288 while (bufsize < newsize) {
3289 bufsize *= 2;
3290 buf = xrealloc(buf, bufsize);
3291 }
3292 if (dlen == 1)
3293 buf[bx++] = *d;
3294 else {
3295 memcpy(buf + bx, d, dlen);
3296 bx += dlen;
3297 }
3298 if (allocated)
3299 free((void *)d);
3300 }
3301 buf[newsize - 1] = '\0';
3302
3303 *size = newsize;
3304 return (buf);
3305 }
3306
3307 /* Map start of C string containing UTF-8 data to grid cell position. */
3308 static void
3309 window_copy_cstrtocellpos(struct grid *gd, u_int ncells, u_int *ppx, u_int *ppy,
3310 const char *str)
3311 {
3312 u_int cell, ccell, px, pywrap, pos, len;
3313 int match;
3314 const struct grid_line *gl;
3315 const char *d;
3316 size_t dlen;
3317 struct {
3318 const char *d;
3319 size_t dlen;
3320 int allocated;
3321 } *cells;
3322
3323 /* Populate the array of cell data. */
3324 cells = xreallocarray(NULL, ncells, sizeof cells[0]);
3325 cell = 0;
3326 px = *ppx;
3327 pywrap = *ppy;
3328 gl = grid_peek_line(gd, pywrap);
3329 while (cell < ncells) {
3330 cells[cell].d = window_copy_cellstring(gl, px,
3331 &cells[cell].dlen, &cells[cell].allocated);
3332 cell++;
3333 px++;
3334 if (px == gd->sx) {
3335 px = 0;
3336 pywrap++;
3337 gl = grid_peek_line(gd, pywrap);
3338 }
3339 }
3340
3341 /* Locate starting cell. */
3342 cell = 0;
3343 len = strlen(str);
3344 while (cell < ncells) {
3345 ccell = cell;
3346 pos = 0;
3347 match = 1;
3348 while (ccell < ncells) {
3349 if (str[pos] == '\0') {
3350 match = 0;
3351 break;
3352 }
3353 d = cells[ccell].d;
3354 dlen = cells[ccell].dlen;
3355 if (dlen == 1) {
3356 if (str[pos] != *d) {
3357 match = 0;
3358 break;
3359 }
3360 pos++;
3361 } else {
3362 if (dlen > len - pos)
3363 dlen = len - pos;
3364 if (memcmp(str + pos, d, dlen) != 0) {
3365 match = 0;
3366 break;
3367 }
3368 pos += dlen;
3369 }
3370 ccell++;
3371 }
3372 if (match)
3373 break;
3374 cell++;
3375 }
3376
3377 /* If not found this will be one past the end. */
3378 px = *ppx + cell;
3379 pywrap = *ppy;
3380 while (px >= gd->sx) {
3381 px -= gd->sx;
3382 pywrap++;
3383 }
3384
3385 *ppx = px;
3386 *ppy = pywrap;
3387
3388 /* Free cell data. */
3389 for (cell = 0; cell < ncells; cell++) {
3390 if (cells[cell].allocated)
3391 free((void *)cells[cell].d);
3392 }
3393 free(cells);
3394 }
3395
3396 static void
3397 window_copy_move_left(struct screen *s, u_int *fx, u_int *fy, int wrapflag)
3398 {
3399 if (*fx == 0) { /* left */
3400 if (*fy == 0) { /* top */
3401 if (wrapflag) {
3402 *fx = screen_size_x(s) - 1;
3403 *fy = screen_hsize(s) + screen_size_y(s) - 1;
3404 }
3405 return;
3406 }
3407 *fx = screen_size_x(s) - 1;
3408 *fy = *fy - 1;
3409 } else
3410 *fx = *fx - 1;
3411 }
3412
3413 static void
3414 window_copy_move_right(struct screen *s, u_int *fx, u_int *fy, int wrapflag)
3415 {
3416 if (*fx == screen_size_x(s) - 1) { /* right */
3417 if (*fy == screen_hsize(s) + screen_size_y(s) - 1) { /* bottom */
3418 if (wrapflag) {
3419 *fx = 0;
3420 *fy = 0;
3421 }
3422 return;
3423 }
3424 *fx = 0;
3425 *fy = *fy + 1;
3426 } else
3427 *fx = *fx + 1;
3428 }
3429
3430 static int
3431 window_copy_is_lowercase(const char *ptr)
3432 {
3433 while (*ptr != '\0') {
3434 if (*ptr != tolower((u_char)*ptr))
3435 return (0);
3436 ++ptr;
3437 }
3438 return (1);
3439 }
3440
3441 /*
3442 * Handle backward wrapped regex searches with overlapping matches. In this case
3443 * find the longest overlapping match from previous wrapped lines.
3444 */
3445 static void
3446 window_copy_search_back_overlap(struct grid *gd, regex_t *preg, u_int *ppx,
3447 u_int *psx, u_int *ppy, u_int endline)
3448 {
3449 u_int endx, endy, oldendx, oldendy, px, py, sx;
3450 int found = 1;
3451
3452 oldendx = *ppx + *psx;
3453 oldendy = *ppy - 1;
3454 while (oldendx > gd->sx - 1) {
3455 oldendx -= gd->sx;
3456 oldendy++;
3457 }
3458 endx = oldendx;
3459 endy = oldendy;
3460 px = *ppx;
3461 py = *ppy;
3462 while (found && px == 0 && py - 1 > endline &&
3463 grid_get_line(gd, py - 2)->flags & GRID_LINE_WRAPPED &&
3464 endx == oldendx && endy == oldendy) {
3465 py--;
3466 found = window_copy_search_rl_regex(gd, &px, &sx, py - 1, 0,
3467 gd->sx, preg);
3468 if (found) {
3469 endx = px + sx;
3470 endy = py - 1;
3471 while (endx > gd->sx - 1) {
3472 endx -= gd->sx;
3473 endy++;
3474 }
3475 if (endx == oldendx && endy == oldendy) {
3476 *ppx = px;
3477 *ppy = py;
3478 }
3479 }
3480 }
3481 }
3482
3483 /*
3484 * Search for text stored in sgd starting from position fx,fy up to endline. If
3485 * found, jump to it. If cis then ignore case. The direction is 0 for searching
3486 * up, down otherwise. If wrap then go to begin/end of grid and try again if
3487 * not found.
3488 */
3489 static int
3490 window_copy_search_jump(struct window_mode_entry *wme, struct grid *gd,
3491 struct grid *sgd, u_int fx, u_int fy, u_int endline, int cis, int wrap,
3492 int direction, int regex)
3493 {
3494 u_int i, px, sx, ssize = 1;
3495 int found = 0, cflags = REG_EXTENDED;
3496 char *sbuf;
3497 regex_t reg;
3498
3499 if (regex) {
3500 sbuf = xmalloc(ssize);
3501 sbuf[0] = '\0';
3502 sbuf = window_copy_stringify(sgd, 0, 0, sgd->sx, sbuf, &ssize);
3503 if (cis)
3504 cflags |= REG_ICASE;
3505 if (regcomp(&reg, sbuf, cflags) != 0) {
3506 free(sbuf);
3507 return (0);
3508 }
3509 free(sbuf);
3510 }
3511
3512 if (direction) {
3513 for (i = fy; i <= endline; i++) {
3514 if (regex) {
3515 found = window_copy_search_lr_regex(gd,
3516 &px, &sx, i, fx, gd->sx, &reg);
3517 } else {
3518 found = window_copy_search_lr(gd, sgd,
3519 &px, i, fx, gd->sx, cis);
3520 }
3521 if (found)
3522 break;
3523 fx = 0;
3524 }
3525 } else {
3526 for (i = fy + 1; endline < i; i--) {
3527 if (regex) {
3528 found = window_copy_search_rl_regex(gd,
3529 &px, &sx, i - 1, 0, fx + 1, &reg);
3530 if (found) {
3531 window_copy_search_back_overlap(gd,
3532 &reg, &px, &sx, &i, endline);
3533 }
3534 } else {
3535 found = window_copy_search_rl(gd, sgd,
3536 &px, i - 1, 0, fx + 1, cis);
3537 }
3538 if (found) {
3539 i--;
3540 break;
3541 }
3542 fx = gd->sx - 1;
3543 }
3544 }
3545 if (regex)
3546 regfree(&reg);
3547
3548 if (found) {
3549 window_copy_scroll_to(wme, px, i, 1);
3550 return (1);
3551 }
3552 if (wrap) {
3553 return (window_copy_search_jump(wme, gd, sgd,
3554 direction ? 0 : gd->sx - 1,
3555 direction ? 0 : gd->hsize + gd->sy - 1, fy, cis, 0,
3556 direction, regex));
3557 }
3558 return (0);
3559 }
3560
3561 static void
3562 window_copy_move_after_search_mark(struct window_copy_mode_data *data,
3563 u_int *fx, u_int *fy, int wrapflag)
3564 {
3565 struct screen *s = data->backing;
3566 u_int at, start;
3567
3568 if (window_copy_search_mark_at(data, *fx, *fy, &start) == 0 &&
3569 data->searchmark[start] != 0) {
3570 while (window_copy_search_mark_at(data, *fx, *fy, &at) == 0) {
3571 if (data->searchmark[at] != data->searchmark[start])
3572 break;
3573 /* Stop if not wrapping and at the end of the grid. */
3574 if (!wrapflag &&
3575 *fx == screen_size_x(s) - 1 &&
3576 *fy == screen_hsize(s) + screen_size_y(s) - 1)
3577 break;
3578
3579 window_copy_move_right(s, fx, fy, wrapflag);
3580 }
3581 }
3582 }
3583
3584 /*
3585 * Search in for text searchstr. If direction is 0 then search up, otherwise
3586 * down.
3587 */
3588 static int
3589 window_copy_search(struct window_mode_entry *wme, int direction, int regex)
3590 {
3591 struct window_pane *wp = wme->wp;
3592 struct window_copy_mode_data *data = wme->data;
3593 struct screen *s = data->backing, ss;
3594 struct screen_write_ctx ctx;
3595 struct grid *gd = s->grid;
3596 const char *str = data->searchstr;
3597 u_int at, endline, fx, fy, start;
3598 int cis, found, keys, visible_only;
3599 int wrapflag;
3600
3601 if (regex && str[strcspn(str, "^$*+()?[].\\")] == '\0')
3602 regex = 0;
3603
3604 data->searchdirection = direction;
3605
3606 if (data->timeout)
3607 return (0);
3608
3609 if (data->searchall || wp->searchstr == NULL ||
3610 wp->searchregex != regex) {
3611 visible_only = 0;
3612 data->searchall = 0;
3613 } else
3614 visible_only = (strcmp(wp->searchstr, str) == 0);
3615 free(wp->searchstr);
3616 wp->searchstr = xstrdup(str);
3617 wp->searchregex = regex;
3618
3619 fx = data->cx;
3620 fy = screen_hsize(data->backing) - data->oy + data->cy;
3621
3622 screen_init(&ss, screen_write_strlen("%s", str), 1, 0);
3623 screen_write_start(&ctx, &ss);
3624 screen_write_nputs(&ctx, -1, &grid_default_cell, "%s", str);
3625 screen_write_stop(&ctx);
3626
3627 wrapflag = options_get_number(wp->window->options, "wrap-search");
3628 cis = window_copy_is_lowercase(str);
3629
3630 keys = options_get_number(wp->window->options, "mode-keys");
3631
3632 if (direction) {
3633 /*
3634 * Behave according to mode-keys. If it is emacs, search forward
3635 * leaves the cursor after the match. If it is vi, the cursor
3636 * remains at the beginning of the match, regardless of
3637 * direction, which means that we need to start the next search
3638 * after the term the cursor is currently on when searching
3639 * forward.
3640 */
3641 if (keys == MODEKEY_VI) {
3642 if (data->searchmark != NULL)
3643 window_copy_move_after_search_mark(data, &fx,
3644 &fy, wrapflag);
3645 else {
3646 /*
3647 * When there are no search marks, start the
3648 * search after the current cursor position.
3649 */
3650 window_copy_move_right(s, &fx, &fy, wrapflag);
3651 }
3652 }
3653 endline = gd->hsize + gd->sy - 1;
3654 }
3655 else {
3656 window_copy_move_left(s, &fx, &fy, wrapflag);
3657 endline = 0;
3658 }
3659
3660 found = window_copy_search_jump(wme, gd, ss.grid, fx, fy, endline, cis,
3661 wrapflag, direction, regex);
3662 if (found) {
3663 window_copy_search_marks(wme, &ss, regex, visible_only);
3664 fx = data->cx;
3665 fy = screen_hsize(data->backing) - data->oy + data->cy;
3666
3667 /*
3668 * When searching forward, if the cursor is not at the beginning
3669 * of the mark, search again.
3670 */
3671 if (direction &&
3672 window_copy_search_mark_at(data, fx, fy, &at) == 0 &&
3673 at > 0 &&
3674 data->searchmark[at] == data->searchmark[at - 1]) {
3675 window_copy_move_after_search_mark(data, &fx, &fy,
3676 wrapflag);
3677 window_copy_search_jump(wme, gd, ss.grid, fx,
3678 fy, endline, cis, wrapflag, direction,
3679 regex);
3680 fx = data->cx;
3681 fy = screen_hsize(data->backing) - data->oy + data->cy;
3682 }
3683
3684 if (direction) {
3685 /*
3686 * When in Emacs mode, position the cursor just after
3687 * the mark.
3688 */
3689 if (keys == MODEKEY_EMACS) {
3690 window_copy_move_after_search_mark(data, &fx,
3691 &fy, wrapflag);
3692 data->cx = fx;
3693 data->cy = fy - screen_hsize(data->backing) +
3694 data-> oy;
3695 }
3696 }
3697 else {
3698 /*
3699 * When searching backward, position the cursor at the
3700 * beginning of the mark.
3701 */
3702 if (window_copy_search_mark_at(data, fx, fy,
3703 &start) == 0) {
3704 while (window_copy_search_mark_at(data, fx, fy,
3705 &at) == 0 &&
3706 data->searchmark[at] ==
3707 data->searchmark[start]) {
3708 data->cx = fx;
3709 data->cy = fy -
3710 screen_hsize(data->backing) +
3711 data-> oy;
3712 if (at == 0)
3713 break;
3714
3715 window_copy_move_left(s, &fx, &fy, 0);
3716 }
3717 }
3718 }
3719 }
3720 window_copy_redraw_screen(wme);
3721
3722 screen_free(&ss);
3723 return (found);
3724 }
3725
3726 static void
3727 window_copy_visible_lines(struct window_copy_mode_data *data, u_int *start,
3728 u_int *end)
3729 {
3730 struct grid *gd = data->backing->grid;
3731 const struct grid_line *gl;
3732
3733 for (*start = gd->hsize - data->oy; *start > 0; (*start)--) {
3734 gl = grid_peek_line(gd, (*start) - 1);
3735 if (~gl->flags & GRID_LINE_WRAPPED)
3736 break;
3737 }
3738 *end = gd->hsize - data->oy + gd->sy;
3739 }
3740
3741 static int
3742 window_copy_search_mark_at(struct window_copy_mode_data *data, u_int px,
3743 u_int py, u_int *at)
3744 {
3745 struct screen *s = data->backing;
3746 struct grid *gd = s->grid;
3747
3748 if (py < gd->hsize - data->oy)
3749 return (-1);
3750 if (py > gd->hsize - data->oy + gd->sy - 1)
3751 return (-1);
3752 *at = ((py - (gd->hsize - data->oy)) * gd->sx) + px;
3753 return (0);
3754 }
3755
3756 static int
3757 window_copy_search_marks(struct window_mode_entry *wme, struct screen *ssp,
3758 int regex, int visible_only)
3759 {
3760 struct window_copy_mode_data *data = wme->data;
3761 struct screen *s = data->backing, ss;
3762 struct screen_write_ctx ctx;
3763 struct grid *gd = s->grid;
3764 int found, cis, stopped = 0;
3765 int cflags = REG_EXTENDED;
3766 u_int px, py, i, b, nfound = 0, width;
3767 u_int ssize = 1, start, end;
3768 char *sbuf;
3769 regex_t reg;
3770 uint64_t stop = 0, tstart, t;
3771
3772 if (ssp == NULL) {
3773 width = screen_write_strlen("%s", data->searchstr);
3774 screen_init(&ss, width, 1, 0);
3775 screen_write_start(&ctx, &ss);
3776 screen_write_nputs(&ctx, -1, &grid_default_cell, "%s",
3777 data->searchstr);
3778 screen_write_stop(&ctx);
3779 ssp = &ss;
3780 } else
3781 width = screen_size_x(ssp);
3782
3783 cis = window_copy_is_lowercase(data->searchstr);
3784
3785 if (regex) {
3786 sbuf = xmalloc(ssize);
3787 sbuf[0] = '\0';
3788 sbuf = window_copy_stringify(ssp->grid, 0, 0, ssp->grid->sx,
3789 sbuf, &ssize);
3790 if (cis)
3791 cflags |= REG_ICASE;
3792 if (regcomp(&reg, sbuf, cflags) != 0) {
3793 free(sbuf);
3794 return (0);
3795 }
3796 free(sbuf);
3797 }
3798 tstart = get_timer();
3799
3800 if (visible_only)
3801 window_copy_visible_lines(data, &start, &end);
3802 else {
3803 start = 0;
3804 end = gd->hsize + gd->sy;
3805 stop = get_timer() + WINDOW_COPY_SEARCH_ALL_TIMEOUT;
3806 }
3807
3808 again:
3809 free(data->searchmark);
3810 data->searchmark = xcalloc(gd->sx, gd->sy);
3811 data->searchgen = 1;
3812
3813 for (py = start; py < end; py++) {
3814 px = 0;
3815 for (;;) {
3816 if (regex) {
3817 found = window_copy_search_lr_regex(gd,
3818 &px, &width, py, px, gd->sx, &reg);
3819 if (!found)
3820 break;
3821 } else {
3822 found = window_copy_search_lr(gd, ssp->grid,
3823 &px, py, px, gd->sx, cis);
3824 if (!found)
3825 break;
3826 }
3827 nfound++;
3828
3829 if (window_copy_search_mark_at(data, px, py, &b) == 0) {
3830 if (b + width > gd->sx * gd->sy)
3831 width = (gd->sx * gd->sy) - b;
3832 for (i = b; i < b + width; i++) {
3833 if (data->searchmark[i] != 0)
3834 continue;
3835 data->searchmark[i] = data->searchgen;
3836 }
3837 if (data->searchgen == UCHAR_MAX)
3838 data->searchgen = 1;
3839 else
3840 data->searchgen++;
3841 }
3842 px += width;
3843 }
3844
3845 t = get_timer();
3846 if (t - tstart > WINDOW_COPY_SEARCH_TIMEOUT) {
3847 data->timeout = 1;
3848 break;
3849 }
3850 if (stop != 0 && t > stop) {
3851 stopped = 1;
3852 break;
3853 }
3854 }
3855 if (data->timeout) {
3856 window_copy_clear_marks(wme);
3857 goto out;
3858 }
3859
3860 if (stopped && stop != 0) {
3861 /* Try again but just the visible context. */
3862 window_copy_visible_lines(data, &start, &end);
3863 stop = 0;
3864 goto again;
3865 }
3866
3867 if (!visible_only) {
3868 if (stopped) {
3869 if (nfound > 1000)
3870 data->searchcount = 1000;
3871 else if (nfound > 100)
3872 data->searchcount = 100;
3873 else if (nfound > 10)
3874 data->searchcount = 10;
3875 else
3876 data->searchcount = -1;
3877 data->searchmore = 1;
3878 } else {
3879 data->searchcount = nfound;
3880 data->searchmore = 0;
3881 }
3882 }
3883
3884 out:
3885 if (ssp == &ss)
3886 screen_free(&ss);
3887 if (regex)
3888 regfree(&reg);
3889 return (1);
3890 }
3891
3892 static void
3893 window_copy_clear_marks(struct window_mode_entry *wme)
3894 {
3895 struct window_copy_mode_data *data = wme->data;
3896
3897 free(data->searchmark);
3898 data->searchmark = NULL;
3899 }
3900
3901 static int
3902 window_copy_search_up(struct window_mode_entry *wme, int regex)
3903 {
3904 return (window_copy_search(wme, 0, regex));
3905 }
3906
3907 static int
3908 window_copy_search_down(struct window_mode_entry *wme, int regex)
3909 {
3910 return (window_copy_search(wme, 1, regex));
3911 }
3912
3913 static void
3914 window_copy_goto_line(struct window_mode_entry *wme, const char *linestr)
3915 {
3916 struct window_copy_mode_data *data = wme->data;
3917 const char *errstr;
3918 int lineno;
3919
3920 lineno = strtonum(linestr, -1, INT_MAX, &errstr);
3921 if (errstr != NULL)
3922 return;
3923 if (lineno < 0 || (u_int)lineno > screen_hsize(data->backing))
3924 lineno = screen_hsize(data->backing);
3925
3926 data->oy = lineno;
3927 window_copy_update_selection(wme, 1, 0);
3928 window_copy_redraw_screen(wme);
3929 }
3930
3931 static void
3932 window_copy_match_start_end(struct window_copy_mode_data *data, u_int at,
3933 u_int *start, u_int *end)
3934 {
3935 struct grid *gd = data->backing->grid;
3936 u_int last = (gd->sy * gd->sx) - 1;
3937 u_char mark = data->searchmark[at];
3938
3939 *start = *end = at;
3940 while (*start != 0 && data->searchmark[*start] == mark)
3941 (*start)--;
3942 if (data->searchmark[*start] != mark)
3943 (*start)++;
3944 while (*end != last && data->searchmark[*end] == mark)
3945 (*end)++;
3946 if (data->searchmark[*end] != mark)
3947 (*end)--;
3948 }
3949
3950 static char *
3951 window_copy_match_at_cursor(struct window_copy_mode_data *data)
3952 {
3953 struct grid *gd = data->backing->grid;
3954 struct grid_cell gc;
3955 u_int at, start, end, cy, px, py;
3956 u_int sx = screen_size_x(data->backing);
3957 char *buf = NULL;
3958 size_t len = 0;
3959
3960 if (data->searchmark == NULL)
3961 return (NULL);
3962
3963 cy = screen_hsize(data->backing) - data->oy + data->cy;
3964 if (window_copy_search_mark_at(data, data->cx, cy, &at) != 0)
3965 return (NULL);
3966 if (data->searchmark[at] == 0) {
3967 /* Allow one position after the match. */
3968 if (at == 0 || data->searchmark[--at] == 0)
3969 return (NULL);
3970 }
3971 window_copy_match_start_end(data, at, &start, &end);
3972
3973 /*
3974 * Cells will not be set in the marked array unless they are valid text
3975 * and wrapping will be taken care of, so we can just copy.
3976 */
3977 for (at = start; at <= end; at++) {
3978 py = at / sx;
3979 px = at - (py * sx);
3980
3981 grid_get_cell(gd, px, gd->hsize + py - data->oy, &gc);
3982 buf = xrealloc(buf, len + gc.data.size + 1);
3983 memcpy(buf + len, gc.data.data, gc.data.size);
3984 len += gc.data.size;
3985 }
3986 if (len != 0)
3987 buf[len] = '\0';
3988 return (buf);
3989 }
3990
3991 static void
3992 window_copy_update_style(struct window_mode_entry *wme, u_int fx, u_int fy,
3993 struct grid_cell *gc, const struct grid_cell *mgc,
3994 const struct grid_cell *cgc, const struct grid_cell *mkgc)
3995 {
3996 struct window_pane *wp = wme->wp;
3997 struct window_copy_mode_data *data = wme->data;
3998 u_int mark, start, end, cy, cursor, current;
3999 int inv = 0, found = 0;
4000 int keys;
4001
4002 if (data->showmark && fy == data->my) {
4003 gc->attr = mkgc->attr;
4004 if (fx == data->mx)
4005 inv = 1;
4006 if (inv) {
4007 gc->fg = mkgc->bg;
4008 gc->bg = mkgc->fg;
4009 }
4010 else {
4011 gc->fg = mkgc->fg;
4012 gc->bg = mkgc->bg;
4013 }
4014 }
4015
4016 if (data->searchmark == NULL)
4017 return;
4018
4019 if (window_copy_search_mark_at(data, fx, fy, &current) != 0)
4020 return;
4021 mark = data->searchmark[current];
4022 if (mark == 0)
4023 return;
4024
4025 cy = screen_hsize(data->backing) - data->oy + data->cy;
4026 if (window_copy_search_mark_at(data, data->cx, cy, &cursor) == 0) {
4027 keys = options_get_number(wp->window->options, "mode-keys");
4028 if (cursor != 0 &&
4029 keys == MODEKEY_EMACS &&
4030 data->searchdirection) {
4031 if (data->searchmark[cursor - 1] == mark) {
4032 cursor--;
4033 found = 1;
4034 }
4035 } else if (data->searchmark[cursor] == mark)
4036 found = 1;
4037 if (found) {
4038 window_copy_match_start_end(data, cursor, &start, &end);
4039 if (current >= start && current <= end) {
4040 gc->attr = cgc->attr;
4041 if (inv) {
4042 gc->fg = cgc->bg;
4043 gc->bg = cgc->fg;
4044 }
4045 else {
4046 gc->fg = cgc->fg;
4047 gc->bg = cgc->bg;
4048 }
4049 return;
4050 }
4051 }
4052 }
4053
4054 gc->attr = mgc->attr;
4055 if (inv) {
4056 gc->fg = mgc->bg;
4057 gc->bg = mgc->fg;
4058 }
4059 else {
4060 gc->fg = mgc->fg;
4061 gc->bg = mgc->bg;
4062 }
4063 }
4064
4065 static void
4066 window_copy_write_one(struct window_mode_entry *wme,
4067 struct screen_write_ctx *ctx, u_int py, u_int fy, u_int nx,
4068 const struct grid_cell *mgc, const struct grid_cell *cgc,
4069 const struct grid_cell *mkgc)
4070 {
4071 struct window_copy_mode_data *data = wme->data;
4072 struct grid *gd = data->backing->grid;
4073 struct grid_cell gc;
4074 u_int fx;
4075
4076 screen_write_cursormove(ctx, 0, py, 0);
4077 for (fx = 0; fx < nx; fx++) {
4078 grid_get_cell(gd, fx, fy, &gc);
4079 if (fx + gc.data.width <= nx) {
4080 window_copy_update_style(wme, fx, fy, &gc, mgc, cgc,
4081 mkgc);
4082 screen_write_cell(ctx, &gc);
4083 }
4084 }
4085 }
4086
4087 static void
4088 window_copy_write_line(struct window_mode_entry *wme,
4089 struct screen_write_ctx *ctx, u_int py)
4090 {
4091 struct window_pane *wp = wme->wp;
4092 struct window_copy_mode_data *data = wme->data;
4093 struct screen *s = &data->screen;
4094 struct options *oo = wp->window->options;
4095 struct grid_line *gl;
4096 struct grid_cell gc, mgc, cgc, mkgc;
4097 char hdr[512], tmp[256], *t;
4098 size_t size = 0;
4099 u_int hsize = screen_hsize(data->backing);
4100
4101 style_apply(&gc, oo, "mode-style", NULL);
4102 gc.flags |= GRID_FLAG_NOPALETTE;
4103 style_apply(&mgc, oo, "copy-mode-match-style", NULL);
4104 mgc.flags |= GRID_FLAG_NOPALETTE;
4105 style_apply(&cgc, oo, "copy-mode-current-match-style", NULL);
4106 cgc.flags |= GRID_FLAG_NOPALETTE;
4107 style_apply(&mkgc, oo, "copy-mode-mark-style", NULL);
4108 mkgc.flags |= GRID_FLAG_NOPALETTE;
4109
4110 if (py == 0 && s->rupper < s->rlower && !data->hide_position) {
4111 gl = grid_get_line(data->backing->grid, hsize - data->oy);
4112 if (gl->time == 0)
4113 xsnprintf(tmp, sizeof tmp, "[%u/%u]", data->oy, hsize);
4114 else {
4115 t = format_pretty_time(gl->time, 1);
4116 xsnprintf(tmp, sizeof tmp, "%s [%u/%u]", t, data->oy,
4117 hsize);
4118 free(t);
4119 }
4120
4121 if (data->searchmark == NULL) {
4122 if (data->timeout) {
4123 size = xsnprintf(hdr, sizeof hdr,
4124 "(timed out) %s", tmp);
4125 } else
4126 size = xsnprintf(hdr, sizeof hdr, "%s", tmp);
4127 } else {
4128 if (data->searchcount == -1)
4129 size = xsnprintf(hdr, sizeof hdr, "%s", tmp);
4130 else {
4131 size = xsnprintf(hdr, sizeof hdr,
4132 "(%d%s results) %s", data->searchcount,
4133 data->searchmore ? "+" : "", tmp);
4134 }
4135 }
4136 if (size > screen_size_x(s))
4137 size = screen_size_x(s);
4138 screen_write_cursormove(ctx, screen_size_x(s) - size, 0, 0);
4139 screen_write_puts(ctx, &gc, "%s", hdr);
4140 } else
4141 size = 0;
4142
4143 if (size < screen_size_x(s)) {
4144 window_copy_write_one(wme, ctx, py, hsize - data->oy + py,
4145 screen_size_x(s) - size, &mgc, &cgc, &mkgc);
4146 }
4147
4148 if (py == data->cy && data->cx == screen_size_x(s)) {
4149 screen_write_cursormove(ctx, screen_size_x(s) - 1, py, 0);
4150 screen_write_putc(ctx, &grid_default_cell, '$');
4151 }
4152 }
4153
4154 static void
4155 window_copy_write_lines(struct window_mode_entry *wme,
4156 struct screen_write_ctx *ctx, u_int py, u_int ny)
4157 {
4158 u_int yy;
4159
4160 for (yy = py; yy < py + ny; yy++)
4161 window_copy_write_line(wme, ctx, py);
4162 }
4163
4164 static void
4165 window_copy_redraw_selection(struct window_mode_entry *wme, u_int old_y)
4166 {
4167 struct window_copy_mode_data *data = wme->data;
4168 struct grid *gd = data->backing->grid;
4169 u_int new_y, start, end;
4170
4171 new_y = data->cy;
4172 if (old_y <= new_y) {
4173 start = old_y;
4174 end = new_y;
4175 } else {
4176 start = new_y;
4177 end = old_y;
4178 }
4179
4180 /*
4181 * In word selection mode the first word on the line below the cursor
4182 * might be selected, so add this line to the redraw area.
4183 */
4184 if (data->selflag == SEL_WORD) {
4185 /* Last grid line in data coordinates. */
4186 if (end < gd->sy + data->oy - 1)
4187 end++;
4188 }
4189 window_copy_redraw_lines(wme, start, end - start + 1);
4190 }
4191
4192 static void
4193 window_copy_redraw_lines(struct window_mode_entry *wme, u_int py, u_int ny)
4194 {
4195 struct window_pane *wp = wme->wp;
4196 struct window_copy_mode_data *data = wme->data;
4197 struct screen_write_ctx ctx;
4198 u_int i;
4199
4200 screen_write_start_pane(&ctx, wp, NULL);
4201 for (i = py; i < py + ny; i++)
4202 window_copy_write_line(wme, &ctx, i);
4203 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
4204 screen_write_stop(&ctx);
4205 }
4206
4207 static void
4208 window_copy_redraw_screen(struct window_mode_entry *wme)
4209 {
4210 struct window_copy_mode_data *data = wme->data;
4211
4212 window_copy_redraw_lines(wme, 0, screen_size_y(&data->screen));
4213 }
4214
4215 static void
4216 window_copy_synchronize_cursor_end(struct window_mode_entry *wme, int begin,
4217 int no_reset)
4218 {
4219 struct window_copy_mode_data *data = wme->data;
4220 u_int xx, yy;
4221
4222 xx = data->cx;
4223 yy = screen_hsize(data->backing) + data->cy - data->oy;
4224 switch (data->selflag) {
4225 case SEL_WORD:
4226 if (no_reset)
4227 break;
4228 begin = 0;
4229 if (data->dy > yy || (data->dy == yy && data->dx > xx)) {
4230 /* Right to left selection. */
4231 window_copy_cursor_previous_word_pos(wme,
4232 data->separators, &xx, &yy);
4233 begin = 1;
4234
4235 /* Reset the end. */
4236 data->endselx = data->endselrx;
4237 data->endsely = data->endselry;
4238 } else {
4239 /* Left to right selection. */
4240 if (xx >= window_copy_find_length(wme, yy) ||
4241 !window_copy_in_set(wme, xx + 1, yy, WHITESPACE)) {
4242 window_copy_cursor_next_word_end_pos(wme,
4243 data->separators, &xx, &yy);
4244 }
4245
4246 /* Reset the start. */
4247 data->selx = data->selrx;
4248 data->sely = data->selry;
4249 }
4250 break;
4251 case SEL_LINE:
4252 if (no_reset)
4253 break;
4254 begin = 0;
4255 if (data->dy > yy) {
4256 /* Right to left selection. */
4257 xx = 0;
4258 begin = 1;
4259
4260 /* Reset the end. */
4261 data->endselx = data->endselrx;
4262 data->endsely = data->endselry;
4263 } else {
4264 /* Left to right selection. */
4265 if (yy < data->endselry)
4266 yy = data->endselry;
4267 xx = window_copy_find_length(wme, yy);
4268
4269 /* Reset the start. */
4270 data->selx = data->selrx;
4271 data->sely = data->selry;
4272 }
4273 break;
4274 case SEL_CHAR:
4275 break;
4276 }
4277 if (begin) {
4278 data->selx = xx;
4279 data->sely = yy;
4280 } else {
4281 data->endselx = xx;
4282 data->endsely = yy;
4283 }
4284 }
4285
4286 static void
4287 window_copy_synchronize_cursor(struct window_mode_entry *wme, int no_reset)
4288 {
4289 struct window_copy_mode_data *data = wme->data;
4290
4291 switch (data->cursordrag) {
4292 case CURSORDRAG_ENDSEL:
4293 window_copy_synchronize_cursor_end(wme, 0, no_reset);
4294 break;
4295 case CURSORDRAG_SEL:
4296 window_copy_synchronize_cursor_end(wme, 1, no_reset);
4297 break;
4298 case CURSORDRAG_NONE:
4299 break;
4300 }
4301 }
4302
4303 static void
4304 window_copy_update_cursor(struct window_mode_entry *wme, u_int cx, u_int cy)
4305 {
4306 struct window_pane *wp = wme->wp;
4307 struct window_copy_mode_data *data = wme->data;
4308 struct screen *s = &data->screen;
4309 struct screen_write_ctx ctx;
4310 u_int old_cx, old_cy;
4311
4312 old_cx = data->cx; old_cy = data->cy;
4313 data->cx = cx; data->cy = cy;
4314 if (old_cx == screen_size_x(s))
4315 window_copy_redraw_lines(wme, old_cy, 1);
4316 if (data->cx == screen_size_x(s))
4317 window_copy_redraw_lines(wme, data->cy, 1);
4318 else {
4319 screen_write_start_pane(&ctx, wp, NULL);
4320 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
4321 screen_write_stop(&ctx);
4322 }
4323 }
4324
4325 static void
4326 window_copy_start_selection(struct window_mode_entry *wme)
4327 {
4328 struct window_copy_mode_data *data = wme->data;
4329
4330 data->selx = data->cx;
4331 data->sely = screen_hsize(data->backing) + data->cy - data->oy;
4332
4333 data->endselx = data->selx;
4334 data->endsely = data->sely;
4335
4336 data->cursordrag = CURSORDRAG_ENDSEL;
4337
4338 window_copy_set_selection(wme, 1, 0);
4339 }
4340
4341 static int
4342 window_copy_adjust_selection(struct window_mode_entry *wme, u_int *selx,
4343 u_int *sely)
4344 {
4345 struct window_copy_mode_data *data = wme->data;
4346 struct screen *s = &data->screen;
4347 u_int sx, sy, ty;
4348 int relpos;
4349
4350 sx = *selx;
4351 sy = *sely;
4352
4353 ty = screen_hsize(data->backing) - data->oy;
4354 if (sy < ty) {
4355 relpos = WINDOW_COPY_REL_POS_ABOVE;
4356 if (!data->rectflag)
4357 sx = 0;
4358 sy = 0;
4359 } else if (sy > ty + screen_size_y(s) - 1) {
4360 relpos = WINDOW_COPY_REL_POS_BELOW;
4361 if (!data->rectflag)
4362 sx = screen_size_x(s) - 1;
4363 sy = screen_size_y(s) - 1;
4364 } else {
4365 relpos = WINDOW_COPY_REL_POS_ON_SCREEN;
4366 sy -= ty;
4367 }
4368
4369 *selx = sx;
4370 *sely = sy;
4371 return (relpos);
4372 }
4373
4374 static int
4375 window_copy_update_selection(struct window_mode_entry *wme, int may_redraw,
4376 int no_reset)
4377 {
4378 struct window_copy_mode_data *data = wme->data;
4379 struct screen *s = &data->screen;
4380
4381 if (s->sel == NULL && data->lineflag == LINE_SEL_NONE)
4382 return (0);
4383 return (window_copy_set_selection(wme, may_redraw, no_reset));
4384 }
4385
4386 static int
4387 window_copy_set_selection(struct window_mode_entry *wme, int may_redraw,
4388 int no_reset)
4389 {
4390 struct window_pane *wp = wme->wp;
4391 struct window_copy_mode_data *data = wme->data;
4392 struct screen *s = &data->screen;
4393 struct options *oo = wp->window->options;
4394 struct grid_cell gc;
4395 u_int sx, sy, cy, endsx, endsy;
4396 int startrelpos, endrelpos;
4397
4398 window_copy_synchronize_cursor(wme, no_reset);
4399
4400 /* Adjust the selection. */
4401 sx = data->selx;
4402 sy = data->sely;
4403 startrelpos = window_copy_adjust_selection(wme, &sx, &sy);
4404
4405 /* Adjust the end of selection. */
4406 endsx = data->endselx;
4407 endsy = data->endsely;
4408 endrelpos = window_copy_adjust_selection(wme, &endsx, &endsy);
4409
4410 /* Selection is outside of the current screen */
4411 if (startrelpos == endrelpos &&
4412 startrelpos != WINDOW_COPY_REL_POS_ON_SCREEN) {
4413 screen_hide_selection(s);
4414 return (0);
4415 }
4416
4417 /* Set colours and selection. */
4418 style_apply(&gc, oo, "mode-style", NULL);
4419 gc.flags |= GRID_FLAG_NOPALETTE;
4420 screen_set_selection(s, sx, sy, endsx, endsy, data->rectflag,
4421 data->modekeys, &gc);
4422
4423 if (data->rectflag && may_redraw) {
4424 /*
4425 * Can't rely on the caller to redraw the right lines for
4426 * rectangle selection - find the highest line and the number
4427 * of lines, and redraw just past that in both directions
4428 */
4429 cy = data->cy;
4430 if (data->cursordrag == CURSORDRAG_ENDSEL) {
4431 if (sy < cy)
4432 window_copy_redraw_lines(wme, sy, cy - sy + 1);
4433 else
4434 window_copy_redraw_lines(wme, cy, sy - cy + 1);
4435 } else {
4436 if (endsy < cy) {
4437 window_copy_redraw_lines(wme, endsy,
4438 cy - endsy + 1);
4439 } else {
4440 window_copy_redraw_lines(wme, cy,
4441 endsy - cy + 1);
4442 }
4443 }
4444 }
4445
4446 return (1);
4447 }
4448
4449 static void *
4450 window_copy_get_selection(struct window_mode_entry *wme, size_t *len)
4451 {
4452 struct window_pane *wp = wme->wp;
4453 struct window_copy_mode_data *data = wme->data;
4454 struct screen *s = &data->screen;
4455 char *buf;
4456 size_t off;
4457 u_int i, xx, yy, sx, sy, ex, ey, ey_last;
4458 u_int firstsx, lastex, restex, restsx, selx;
4459 int keys;
4460
4461 if (data->screen.sel == NULL && data->lineflag == LINE_SEL_NONE) {
4462 buf = window_copy_match_at_cursor(data);
4463 if (buf != NULL)
4464 *len = strlen(buf);
4465 else
4466 *len = 0;
4467 return (buf);
4468 }
4469
4470 buf = xmalloc(1);
4471 off = 0;
4472
4473 *buf = '\0';
4474
4475 /*
4476 * The selection extends from selx,sely to (adjusted) cx,cy on
4477 * the base screen.
4478 */
4479
4480 /* Find start and end. */
4481 xx = data->endselx;
4482 yy = data->endsely;
4483 if (yy < data->sely || (yy == data->sely && xx < data->selx)) {
4484 sx = xx; sy = yy;
4485 ex = data->selx; ey = data->sely;
4486 } else {
4487 sx = data->selx; sy = data->sely;
4488 ex = xx; ey = yy;
4489 }
4490
4491 /* Trim ex to end of line. */
4492 ey_last = window_copy_find_length(wme, ey);
4493 if (ex > ey_last)
4494 ex = ey_last;
4495
4496 /*
4497 * Deal with rectangle-copy if necessary; four situations: start of
4498 * first line (firstsx), end of last line (lastex), start (restsx) and
4499 * end (restex) of all other lines.
4500 */
4501 xx = screen_size_x(s);
4502
4503 /*
4504 * Behave according to mode-keys. If it is emacs, copy like emacs,
4505 * keeping the top-left-most character, and dropping the
4506 * bottom-right-most, regardless of copy direction. If it is vi, also
4507 * keep bottom-right-most character.
4508 */
4509 keys = options_get_number(wp->window->options, "mode-keys");
4510 if (data->rectflag) {
4511 /*
4512 * Need to ignore the column with the cursor in it, which for
4513 * rectangular copy means knowing which side the cursor is on.
4514 */
4515 if (data->cursordrag == CURSORDRAG_ENDSEL)
4516 selx = data->selx;
4517 else
4518 selx = data->endselx;
4519 if (selx < data->cx) {
4520 /* Selection start is on the left. */
4521 if (keys == MODEKEY_EMACS) {
4522 lastex = data->cx;
4523 restex = data->cx;
4524 }
4525 else {
4526 lastex = data->cx + 1;
4527 restex = data->cx + 1;
4528 }
4529 firstsx = selx;
4530 restsx = selx;
4531 } else {
4532 /* Cursor is on the left. */
4533 lastex = selx + 1;
4534 restex = selx + 1;
4535 firstsx = data->cx;
4536 restsx = data->cx;
4537 }
4538 } else {
4539 if (keys == MODEKEY_EMACS)
4540 lastex = ex;
4541 else
4542 lastex = ex + 1;
4543 restex = xx;
4544 firstsx = sx;
4545 restsx = 0;
4546 }
4547
4548 /* Copy the lines. */
4549 for (i = sy; i <= ey; i++) {
4550 window_copy_copy_line(wme, &buf, &off, i,
4551 (i == sy ? firstsx : restsx),
4552 (i == ey ? lastex : restex));
4553 }
4554
4555 /* Don't bother if no data. */
4556 if (off == 0) {
4557 free(buf);
4558 *len = 0;
4559 return (NULL);
4560 }
4561 /* Remove final \n (unless at end in vi mode). */
4562 if (keys == MODEKEY_EMACS || lastex <= ey_last) {
4563 if (~grid_get_line(data->backing->grid, ey)->flags &
4564 GRID_LINE_WRAPPED || lastex != ey_last)
4565 off -= 1;
4566 }
4567 *len = off;
4568 return (buf);
4569 }
4570
4571 static void
4572 window_copy_copy_buffer(struct window_mode_entry *wme, const char *prefix,
4573 void *buf, size_t len)
4574 {
4575 struct window_pane *wp = wme->wp;
4576 struct screen_write_ctx ctx;
4577
4578 if (options_get_number(global_options, "set-clipboard") != 0) {
4579 screen_write_start_pane(&ctx, wp, NULL);
4580 screen_write_setselection(&ctx, "", buf, len);
4581 screen_write_stop(&ctx);
4582 notify_pane("pane-set-clipboard", wp);
4583 }
4584
4585 paste_add(prefix, buf, len);
4586 }
4587
4588 static void *
4589 window_copy_pipe_run(struct window_mode_entry *wme, struct session *s,
4590 const char *cmd, size_t *len)
4591 {
4592 void *buf;
4593 struct job *job;
4594
4595 buf = window_copy_get_selection(wme, len);
4596 if (cmd == NULL || *cmd == '\0')
4597 cmd = options_get_string(global_options, "copy-command");
4598 if (cmd != NULL && *cmd != '\0') {
4599 job = job_run(cmd, 0, NULL, NULL, s, NULL, NULL, NULL, NULL,
4600 NULL, JOB_NOWAIT, -1, -1);
4601 bufferevent_write(job_get_event(job), buf, *len);
4602 }
4603 return (buf);
4604 }
4605
4606 static void
4607 window_copy_pipe(struct window_mode_entry *wme, struct session *s,
4608 const char *cmd)
4609 {
4610 size_t len;
4611
4612 window_copy_pipe_run(wme, s, cmd, &len);
4613 }
4614
4615 static void
4616 window_copy_copy_pipe(struct window_mode_entry *wme, struct session *s,
4617 const char *prefix, const char *cmd)
4618 {
4619 void *buf;
4620 size_t len;
4621
4622 buf = window_copy_pipe_run(wme, s, cmd, &len);
4623 if (buf != NULL)
4624 window_copy_copy_buffer(wme, prefix, buf, len);
4625 }
4626
4627 static void
4628 window_copy_copy_selection(struct window_mode_entry *wme, const char *prefix)
4629 {
4630 char *buf;
4631 size_t len;
4632
4633 buf = window_copy_get_selection(wme, &len);
4634 if (buf != NULL)
4635 window_copy_copy_buffer(wme, prefix, buf, len);
4636 }
4637
4638 static void
4639 window_copy_append_selection(struct window_mode_entry *wme)
4640 {
4641 struct window_pane *wp = wme->wp;
4642 char *buf;
4643 struct paste_buffer *pb;
4644 const char *bufdata, *bufname = NULL;
4645 size_t len, bufsize;
4646 struct screen_write_ctx ctx;
4647
4648 buf = window_copy_get_selection(wme, &len);
4649 if (buf == NULL)
4650 return;
4651
4652 if (options_get_number(global_options, "set-clipboard") != 0) {
4653 screen_write_start_pane(&ctx, wp, NULL);
4654 screen_write_setselection(&ctx, "", buf, len);
4655 screen_write_stop(&ctx);
4656 notify_pane("pane-set-clipboard", wp);
4657 }
4658
4659 pb = paste_get_top(&bufname);
4660 if (pb != NULL) {
4661 bufdata = paste_buffer_data(pb, &bufsize);
4662 buf = xrealloc(buf, len + bufsize);
4663 memmove(buf + bufsize, buf, len);
4664 memcpy(buf, bufdata, bufsize);
4665 len += bufsize;
4666 }
4667 if (paste_set(buf, len, bufname, NULL) != 0)
4668 free(buf);
4669 }
4670
4671 static void
4672 window_copy_copy_line(struct window_mode_entry *wme, char **buf, size_t *off,
4673 u_int sy, u_int sx, u_int ex)
4674 {
4675 struct window_copy_mode_data *data = wme->data;
4676 struct grid *gd = data->backing->grid;
4677 struct grid_cell gc;
4678 struct grid_line *gl;
4679 struct utf8_data ud;
4680 u_int i, xx, wrapped = 0;
4681 const char *s;
4682
4683 if (sx > ex)
4684 return;
4685
4686 /*
4687 * Work out if the line was wrapped at the screen edge and all of it is
4688 * on screen.
4689 */
4690 gl = grid_get_line(gd, sy);
4691 if (gl->flags & GRID_LINE_WRAPPED && gl->cellsize <= gd->sx)
4692 wrapped = 1;
4693
4694 /* If the line was wrapped, don't strip spaces (use the full length). */
4695 if (wrapped)
4696 xx = gl->cellsize;
4697 else
4698 xx = window_copy_find_length(wme, sy);
4699 if (ex > xx)
4700 ex = xx;
4701 if (sx > xx)
4702 sx = xx;
4703
4704 if (sx < ex) {
4705 for (i = sx; i < ex; i++) {
4706 grid_get_cell(gd, i, sy, &gc);
4707 if (gc.flags & GRID_FLAG_PADDING)
4708 continue;
4709 utf8_copy(&ud, &gc.data);
4710 if (ud.size == 1 && (gc.attr & GRID_ATTR_CHARSET)) {
4711 s = tty_acs_get(NULL, ud.data[0]);
4712 if (s != NULL && strlen(s) <= sizeof ud.data) {
4713 ud.size = strlen(s);
4714 memcpy(ud.data, s, ud.size);
4715 }
4716 }
4717
4718 *buf = xrealloc(*buf, (*off) + ud.size);
4719 memcpy(*buf + *off, ud.data, ud.size);
4720 *off += ud.size;
4721 }
4722 }
4723
4724 /* Only add a newline if the line wasn't wrapped. */
4725 if (!wrapped || ex != xx) {
4726 *buf = xrealloc(*buf, (*off) + 1);
4727 (*buf)[(*off)++] = '\n';
4728 }
4729 }
4730
4731 static void
4732 window_copy_clear_selection(struct window_mode_entry *wme)
4733 {
4734 struct window_copy_mode_data *data = wme->data;
4735 u_int px, py;
4736
4737 screen_clear_selection(&data->screen);
4738
4739 data->cursordrag = CURSORDRAG_NONE;
4740 data->lineflag = LINE_SEL_NONE;
4741 data->selflag = SEL_CHAR;
4742
4743 py = screen_hsize(data->backing) + data->cy - data->oy;
4744 px = window_copy_find_length(wme, py);
4745 if (data->cx > px)
4746 window_copy_update_cursor(wme, px, data->cy);
4747 }
4748
4749 static int
4750 window_copy_in_set(struct window_mode_entry *wme, u_int px, u_int py,
4751 const char *set)
4752 {
4753 struct window_copy_mode_data *data = wme->data;
4754 struct grid_cell gc;
4755
4756 grid_get_cell(data->backing->grid, px, py, &gc);
4757 if (gc.flags & GRID_FLAG_PADDING)
4758 return (0);
4759 return (utf8_cstrhas(set, &gc.data));
4760 }
4761
4762 static u_int
4763 window_copy_find_length(struct window_mode_entry *wme, u_int py)
4764 {
4765 struct window_copy_mode_data *data = wme->data;
4766
4767 return (grid_line_length(data->backing->grid, py));
4768 }
4769
4770 static void
4771 window_copy_cursor_start_of_line(struct window_mode_entry *wme)
4772 {
4773 struct window_copy_mode_data *data = wme->data;
4774 struct screen *back_s = data->backing;
4775 struct grid_reader gr;
4776 u_int px, py, oldy, hsize;
4777
4778 px = data->cx;
4779 hsize = screen_hsize(back_s);
4780 py = hsize + data->cy - data->oy;
4781 oldy = data->cy;
4782
4783 grid_reader_start(&gr, back_s->grid, px, py);
4784 grid_reader_cursor_start_of_line(&gr, 1);
4785 grid_reader_get_cursor(&gr, &px, &py);
4786 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
4787 }
4788
4789 static void
4790 window_copy_cursor_back_to_indentation(struct window_mode_entry *wme)
4791 {
4792 struct window_copy_mode_data *data = wme->data;
4793 struct screen *back_s = data->backing;
4794 struct grid_reader gr;
4795 u_int px, py, oldy, hsize;
4796
4797 px = data->cx;
4798 hsize = screen_hsize(back_s);
4799 py = hsize + data->cy - data->oy;
4800 oldy = data->cy;
4801
4802 grid_reader_start(&gr, back_s->grid, px, py);
4803 grid_reader_cursor_back_to_indentation(&gr);
4804 grid_reader_get_cursor(&gr, &px, &py);
4805 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
4806 }
4807
4808 static void
4809 window_copy_cursor_end_of_line(struct window_mode_entry *wme)
4810 {
4811 struct window_copy_mode_data *data = wme->data;
4812 struct screen *back_s = data->backing;
4813 struct grid_reader gr;
4814 u_int px, py, oldy, hsize;
4815
4816 px = data->cx;
4817 hsize = screen_hsize(back_s);
4818 py = hsize + data->cy - data->oy;
4819 oldy = data->cy;
4820
4821 grid_reader_start(&gr, back_s->grid, px, py);
4822 if (data->screen.sel != NULL && data->rectflag)
4823 grid_reader_cursor_end_of_line(&gr, 1, 1);
4824 else
4825 grid_reader_cursor_end_of_line(&gr, 1, 0);
4826 grid_reader_get_cursor(&gr, &px, &py);
4827 window_copy_acquire_cursor_down(wme, hsize, screen_size_y(back_s),
4828 data->oy, oldy, px, py, 0);
4829 }
4830
4831 static void
4832 window_copy_other_end(struct window_mode_entry *wme)
4833 {
4834 struct window_copy_mode_data *data = wme->data;
4835 struct screen *s = &data->screen;
4836 u_int selx, sely, cy, yy, hsize;
4837
4838 if (s->sel == NULL && data->lineflag == LINE_SEL_NONE)
4839 return;
4840
4841 if (data->lineflag == LINE_SEL_LEFT_RIGHT)
4842 data->lineflag = LINE_SEL_RIGHT_LEFT;
4843 else if (data->lineflag == LINE_SEL_RIGHT_LEFT)
4844 data->lineflag = LINE_SEL_LEFT_RIGHT;
4845
4846 switch (data->cursordrag) {
4847 case CURSORDRAG_NONE:
4848 case CURSORDRAG_SEL:
4849 data->cursordrag = CURSORDRAG_ENDSEL;
4850 break;
4851 case CURSORDRAG_ENDSEL:
4852 data->cursordrag = CURSORDRAG_SEL;
4853 break;
4854 }
4855
4856 selx = data->endselx;
4857 sely = data->endsely;
4858 if (data->cursordrag == CURSORDRAG_SEL) {
4859 selx = data->selx;
4860 sely = data->sely;
4861 }
4862
4863 cy = data->cy;
4864 yy = screen_hsize(data->backing) + data->cy - data->oy;
4865
4866 data->cx = selx;
4867
4868 hsize = screen_hsize(data->backing);
4869 if (sely < hsize - data->oy) { /* above */
4870 data->oy = hsize - sely;
4871 data->cy = 0;
4872 } else if (sely > hsize - data->oy + screen_size_y(s)) { /* below */
4873 data->oy = hsize - sely + screen_size_y(s) - 1;
4874 data->cy = screen_size_y(s) - 1;
4875 } else
4876 data->cy = cy + sely - yy;
4877
4878 window_copy_update_selection(wme, 1, 1);
4879 window_copy_redraw_screen(wme);
4880 }
4881
4882 static void
4883 window_copy_cursor_left(struct window_mode_entry *wme)
4884 {
4885 struct window_copy_mode_data *data = wme->data;
4886 struct screen *back_s = data->backing;
4887 struct grid_reader gr;
4888 u_int px, py, oldy, hsize;
4889
4890 px = data->cx;
4891 hsize = screen_hsize(back_s);
4892 py = hsize + data->cy - data->oy;
4893 oldy = data->cy;
4894
4895 grid_reader_start(&gr, back_s->grid, px, py);
4896 grid_reader_cursor_left(&gr, 1);
4897 grid_reader_get_cursor(&gr, &px, &py);
4898 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
4899 }
4900
4901 static void
4902 window_copy_cursor_right(struct window_mode_entry *wme, int all)
4903 {
4904 struct window_copy_mode_data *data = wme->data;
4905 struct screen *back_s = data->backing;
4906 struct grid_reader gr;
4907 u_int px, py, oldy, hsize;
4908
4909 px = data->cx;
4910 hsize = screen_hsize(back_s);
4911 py = hsize + data->cy - data->oy;
4912 oldy = data->cy;
4913
4914 grid_reader_start(&gr, back_s->grid, px, py);
4915 grid_reader_cursor_right(&gr, 1, all);
4916 grid_reader_get_cursor(&gr, &px, &py);
4917 window_copy_acquire_cursor_down(wme, hsize, screen_size_y(back_s),
4918 data->oy, oldy, px, py, 0);
4919 }
4920
4921 static void
4922 window_copy_cursor_up(struct window_mode_entry *wme, int scroll_only)
4923 {
4924 struct window_copy_mode_data *data = wme->data;
4925 struct screen *s = &data->screen;
4926 u_int ox, oy, px, py;
4927 int norectsel;
4928
4929 norectsel = data->screen.sel == NULL || !data->rectflag;
4930 oy = screen_hsize(data->backing) + data->cy - data->oy;
4931 ox = window_copy_find_length(wme, oy);
4932 if (norectsel && data->cx != ox) {
4933 data->lastcx = data->cx;
4934 data->lastsx = ox;
4935 }
4936
4937 if (data->lineflag == LINE_SEL_LEFT_RIGHT && oy == data->sely)
4938 window_copy_other_end(wme);
4939
4940 if (scroll_only || data->cy == 0) {
4941 if (norectsel)
4942 data->cx = data->lastcx;
4943 window_copy_scroll_down(wme, 1);
4944 if (scroll_only) {
4945 if (data->cy == screen_size_y(s) - 1)
4946 window_copy_redraw_lines(wme, data->cy, 1);
4947 else
4948 window_copy_redraw_lines(wme, data->cy, 2);
4949 }
4950 } else {
4951 if (norectsel) {
4952 window_copy_update_cursor(wme, data->lastcx,
4953 data->cy - 1);
4954 } else
4955 window_copy_update_cursor(wme, data->cx, data->cy - 1);
4956 if (window_copy_update_selection(wme, 1, 0)) {
4957 if (data->cy == screen_size_y(s) - 1)
4958 window_copy_redraw_lines(wme, data->cy, 1);
4959 else
4960 window_copy_redraw_lines(wme, data->cy, 2);
4961 }
4962 }
4963
4964 if (norectsel) {
4965 py = screen_hsize(data->backing) + data->cy - data->oy;
4966 px = window_copy_find_length(wme, py);
4967 if ((data->cx >= data->lastsx && data->cx != px) ||
4968 data->cx > px)
4969 {
4970 window_copy_update_cursor(wme, px, data->cy);
4971 if (window_copy_update_selection(wme, 1, 0))
4972 window_copy_redraw_lines(wme, data->cy, 1);
4973 }
4974 }
4975
4976 if (data->lineflag == LINE_SEL_LEFT_RIGHT)
4977 {
4978 py = screen_hsize(data->backing) + data->cy - data->oy;
4979 if (data->rectflag)
4980 px = screen_size_x(data->backing);
4981 else
4982 px = window_copy_find_length(wme, py);
4983 window_copy_update_cursor(wme, px, data->cy);
4984 if (window_copy_update_selection(wme, 1, 0))
4985 window_copy_redraw_lines(wme, data->cy, 1);
4986 }
4987 else if (data->lineflag == LINE_SEL_RIGHT_LEFT)
4988 {
4989 window_copy_update_cursor(wme, 0, data->cy);
4990 if (window_copy_update_selection(wme, 1, 0))
4991 window_copy_redraw_lines(wme, data->cy, 1);
4992 }
4993 }
4994
4995 static void
4996 window_copy_cursor_down(struct window_mode_entry *wme, int scroll_only)
4997 {
4998 struct window_copy_mode_data *data = wme->data;
4999 struct screen *s = &data->screen;
5000 u_int ox, oy, px, py;
5001 int norectsel;
5002
5003 norectsel = data->screen.sel == NULL || !data->rectflag;
5004 oy = screen_hsize(data->backing) + data->cy - data->oy;
5005 ox = window_copy_find_length(wme, oy);
5006 if (norectsel && data->cx != ox) {
5007 data->lastcx = data->cx;
5008 data->lastsx = ox;
5009 }
5010
5011 if (data->lineflag == LINE_SEL_RIGHT_LEFT && oy == data->endsely)
5012 window_copy_other_end(wme);
5013
5014 if (scroll_only || data->cy == screen_size_y(s) - 1) {
5015 if (norectsel)
5016 data->cx = data->lastcx;
5017 window_copy_scroll_up(wme, 1);
5018 if (scroll_only && data->cy > 0)
5019 window_copy_redraw_lines(wme, data->cy - 1, 2);
5020 } else {
5021 if (norectsel) {
5022 window_copy_update_cursor(wme, data->lastcx,
5023 data->cy + 1);
5024 } else
5025 window_copy_update_cursor(wme, data->cx, data->cy + 1);
5026 if (window_copy_update_selection(wme, 1, 0))
5027 window_copy_redraw_lines(wme, data->cy - 1, 2);
5028 }
5029
5030 if (norectsel) {
5031 py = screen_hsize(data->backing) + data->cy - data->oy;
5032 px = window_copy_find_length(wme, py);
5033 if ((data->cx >= data->lastsx && data->cx != px) ||
5034 data->cx > px)
5035 {
5036 window_copy_update_cursor(wme, px, data->cy);
5037 if (window_copy_update_selection(wme, 1, 0))
5038 window_copy_redraw_lines(wme, data->cy, 1);
5039 }
5040 }
5041
5042 if (data->lineflag == LINE_SEL_LEFT_RIGHT)
5043 {
5044 py = screen_hsize(data->backing) + data->cy - data->oy;
5045 if (data->rectflag)
5046 px = screen_size_x(data->backing);
5047 else
5048 px = window_copy_find_length(wme, py);
5049 window_copy_update_cursor(wme, px, data->cy);
5050 if (window_copy_update_selection(wme, 1, 0))
5051 window_copy_redraw_lines(wme, data->cy, 1);
5052 }
5053 else if (data->lineflag == LINE_SEL_RIGHT_LEFT)
5054 {
5055 window_copy_update_cursor(wme, 0, data->cy);
5056 if (window_copy_update_selection(wme, 1, 0))
5057 window_copy_redraw_lines(wme, data->cy, 1);
5058 }
5059 }
5060
5061 static void
5062 window_copy_cursor_jump(struct window_mode_entry *wme)
5063 {
5064 struct window_copy_mode_data *data = wme->data;
5065 struct screen *back_s = data->backing;
5066 struct grid_reader gr;
5067 u_int px, py, oldy, hsize;
5068
5069 px = data->cx + 1;
5070 hsize = screen_hsize(back_s);
5071 py = hsize + data->cy - data->oy;
5072 oldy = data->cy;
5073
5074 grid_reader_start(&gr, back_s->grid, px, py);
5075 if (grid_reader_cursor_jump(&gr, data->jumpchar)) {
5076 grid_reader_get_cursor(&gr, &px, &py);
5077 window_copy_acquire_cursor_down(wme, hsize,
5078 screen_size_y(back_s), data->oy, oldy, px, py, 0);
5079 }
5080 }
5081
5082 static void
5083 window_copy_cursor_jump_back(struct window_mode_entry *wme)
5084 {
5085 struct window_copy_mode_data *data = wme->data;
5086 struct screen *back_s = data->backing;
5087 struct grid_reader gr;
5088 u_int px, py, oldy, hsize;
5089
5090 px = data->cx;
5091 hsize = screen_hsize(back_s);
5092 py = hsize + data->cy - data->oy;
5093 oldy = data->cy;
5094
5095 grid_reader_start(&gr, back_s->grid, px, py);
5096 grid_reader_cursor_left(&gr, 0);
5097 if (grid_reader_cursor_jump_back(&gr, data->jumpchar)) {
5098 grid_reader_get_cursor(&gr, &px, &py);
5099 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px,
5100 py);
5101 }
5102 }
5103
5104 static void
5105 window_copy_cursor_jump_to(struct window_mode_entry *wme)
5106 {
5107 struct window_copy_mode_data *data = wme->data;
5108 struct screen *back_s = data->backing;
5109 struct grid_reader gr;
5110 u_int px, py, oldy, hsize;
5111
5112 px = data->cx + 2;
5113 hsize = screen_hsize(back_s);
5114 py = hsize + data->cy - data->oy;
5115 oldy = data->cy;
5116
5117 grid_reader_start(&gr, back_s->grid, px, py);
5118 if (grid_reader_cursor_jump(&gr, data->jumpchar)) {
5119 grid_reader_cursor_left(&gr, 1);
5120 grid_reader_get_cursor(&gr, &px, &py);
5121 window_copy_acquire_cursor_down(wme, hsize,
5122 screen_size_y(back_s), data->oy, oldy, px, py, 0);
5123 }
5124 }
5125
5126 static void
5127 window_copy_cursor_jump_to_back(struct window_mode_entry *wme)
5128 {
5129 struct window_copy_mode_data *data = wme->data;
5130 struct screen *back_s = data->backing;
5131 struct grid_reader gr;
5132 u_int px, py, oldy, hsize;
5133
5134 px = data->cx;
5135 hsize = screen_hsize(back_s);
5136 py = hsize + data->cy - data->oy;
5137 oldy = data->cy;
5138
5139 grid_reader_start(&gr, back_s->grid, px, py);
5140 grid_reader_cursor_left(&gr, 0);
5141 grid_reader_cursor_left(&gr, 0);
5142 if (grid_reader_cursor_jump_back(&gr, data->jumpchar)) {
5143 grid_reader_cursor_right(&gr, 1, 0);
5144 grid_reader_get_cursor(&gr, &px, &py);
5145 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px,
5146 py);
5147 }
5148 }
5149
5150 static void
5151 window_copy_cursor_next_word(struct window_mode_entry *wme,
5152 const char *separators)
5153 {
5154 struct window_copy_mode_data *data = wme->data;
5155 struct screen *back_s = data->backing;
5156 struct grid_reader gr;
5157 u_int px, py, oldy, hsize;
5158
5159 px = data->cx;
5160 hsize = screen_hsize(back_s);
5161 py = hsize + data->cy - data->oy;
5162 oldy = data->cy;
5163
5164 grid_reader_start(&gr, back_s->grid, px, py);
5165 grid_reader_cursor_next_word(&gr, separators);
5166 grid_reader_get_cursor(&gr, &px, &py);
5167 window_copy_acquire_cursor_down(wme, hsize, screen_size_y(back_s),
5168 data->oy, oldy, px, py, 0);
5169 }
5170
5171 /* Compute the next place where a word ends. */
5172 static void
5173 window_copy_cursor_next_word_end_pos(struct window_mode_entry *wme,
5174 const char *separators, u_int *ppx, u_int *ppy)
5175 {
5176 struct window_pane *wp = wme->wp;
5177 struct window_copy_mode_data *data = wme->data;
5178 struct options *oo = wp->window->options;
5179 struct screen *back_s = data->backing;
5180 struct grid_reader gr;
5181 u_int px, py, hsize;
5182
5183 px = data->cx;
5184 hsize = screen_hsize(back_s);
5185 py = hsize + data->cy - data->oy;
5186
5187 grid_reader_start(&gr, back_s->grid, px, py);
5188 if (options_get_number(oo, "mode-keys") == MODEKEY_VI) {
5189 if (!grid_reader_in_set(&gr, WHITESPACE))
5190 grid_reader_cursor_right(&gr, 0, 0);
5191 grid_reader_cursor_next_word_end(&gr, separators);
5192 grid_reader_cursor_left(&gr, 1);
5193 } else
5194 grid_reader_cursor_next_word_end(&gr, separators);
5195 grid_reader_get_cursor(&gr, &px, &py);
5196 *ppx = px;
5197 *ppy = py;
5198 }
5199
5200 /* Move to the next place where a word ends. */
5201 static void
5202 window_copy_cursor_next_word_end(struct window_mode_entry *wme,
5203 const char *separators, int no_reset)
5204 {
5205 struct window_pane *wp = wme->wp;
5206 struct window_copy_mode_data *data = wme->data;
5207 struct options *oo = wp->window->options;
5208 struct screen *back_s = data->backing;
5209 struct grid_reader gr;
5210 u_int px, py, oldy, hsize;
5211
5212 px = data->cx;
5213 hsize = screen_hsize(back_s);
5214 py = hsize + data->cy - data->oy;
5215 oldy = data->cy;
5216
5217 grid_reader_start(&gr, back_s->grid, px, py);
5218 if (options_get_number(oo, "mode-keys") == MODEKEY_VI) {
5219 if (!grid_reader_in_set(&gr, WHITESPACE))
5220 grid_reader_cursor_right(&gr, 0, 0);
5221 grid_reader_cursor_next_word_end(&gr, separators);
5222 grid_reader_cursor_left(&gr, 1);
5223 } else
5224 grid_reader_cursor_next_word_end(&gr, separators);
5225 grid_reader_get_cursor(&gr, &px, &py);
5226 window_copy_acquire_cursor_down(wme, hsize, screen_size_y(back_s),
5227 data->oy, oldy, px, py, no_reset);
5228 }
5229
5230 /* Compute the previous place where a word begins. */
5231 static void
5232 window_copy_cursor_previous_word_pos(struct window_mode_entry *wme,
5233 const char *separators, u_int *ppx, u_int *ppy)
5234 {
5235 struct window_copy_mode_data *data = wme->data;
5236 struct screen *back_s = data->backing;
5237 struct grid_reader gr;
5238 u_int px, py, hsize;
5239
5240 px = data->cx;
5241 hsize = screen_hsize(back_s);
5242 py = hsize + data->cy - data->oy;
5243
5244 grid_reader_start(&gr, back_s->grid, px, py);
5245 grid_reader_cursor_previous_word(&gr, separators, /* already= */ 0,
5246 /* stop_at_eol= */ 1);
5247 grid_reader_get_cursor(&gr, &px, &py);
5248 *ppx = px;
5249 *ppy = py;
5250 }
5251
5252 /* Move to the previous place where a word begins. */
5253 static void
5254 window_copy_cursor_previous_word(struct window_mode_entry *wme,
5255 const char *separators, int already)
5256 {
5257 struct window_copy_mode_data *data = wme->data;
5258 struct window *w = wme->wp->window;
5259 struct screen *back_s = data->backing;
5260 struct grid_reader gr;
5261 u_int px, py, oldy, hsize;
5262 int stop_at_eol;
5263
5264 if (options_get_number(w->options, "mode-keys") == MODEKEY_EMACS)
5265 stop_at_eol = 1;
5266 else
5267 stop_at_eol = 0;
5268
5269 px = data->cx;
5270 hsize = screen_hsize(back_s);
5271 py = hsize + data->cy - data->oy;
5272 oldy = data->cy;
5273
5274 grid_reader_start(&gr, back_s->grid, px, py);
5275 grid_reader_cursor_previous_word(&gr, separators, already, stop_at_eol);
5276 grid_reader_get_cursor(&gr, &px, &py);
5277 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
5278 }
5279
5280 static void
5281 window_copy_scroll_up(struct window_mode_entry *wme, u_int ny)
5282 {
5283 struct window_pane *wp = wme->wp;
5284 struct window_copy_mode_data *data = wme->data;
5285 struct screen *s = &data->screen;
5286 struct screen_write_ctx ctx;
5287
5288 if (data->oy < ny)
5289 ny = data->oy;
5290 if (ny == 0)
5291 return;
5292 data->oy -= ny;
5293
5294 if (data->searchmark != NULL && !data->timeout)
5295 window_copy_search_marks(wme, NULL, data->searchregex, 1);
5296 window_copy_update_selection(wme, 0, 0);
5297
5298 screen_write_start_pane(&ctx, wp, NULL);
5299 screen_write_cursormove(&ctx, 0, 0, 0);
5300 screen_write_deleteline(&ctx, ny, 8);
5301 window_copy_write_lines(wme, &ctx, screen_size_y(s) - ny, ny);
5302 window_copy_write_line(wme, &ctx, 0);
5303 if (screen_size_y(s) > 1)
5304 window_copy_write_line(wme, &ctx, 1);
5305 if (screen_size_y(s) > 3)
5306 window_copy_write_line(wme, &ctx, screen_size_y(s) - 2);
5307 if (s->sel != NULL && screen_size_y(s) > ny)
5308 window_copy_write_line(wme, &ctx, screen_size_y(s) - ny - 1);
5309 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
5310 screen_write_stop(&ctx);
5311 }
5312
5313 static void
5314 window_copy_scroll_down(struct window_mode_entry *wme, u_int ny)
5315 {
5316 struct window_pane *wp = wme->wp;
5317 struct window_copy_mode_data *data = wme->data;
5318 struct screen *s = &data->screen;
5319 struct screen_write_ctx ctx;
5320
5321 if (ny > screen_hsize(data->backing))
5322 return;
5323
5324 if (data->oy > screen_hsize(data->backing) - ny)
5325 ny = screen_hsize(data->backing) - data->oy;
5326 if (ny == 0)
5327 return;
5328 data->oy += ny;
5329
5330 if (data->searchmark != NULL && !data->timeout)
5331 window_copy_search_marks(wme, NULL, data->searchregex, 1);
5332 window_copy_update_selection(wme, 0, 0);
5333
5334 screen_write_start_pane(&ctx, wp, NULL);
5335 screen_write_cursormove(&ctx, 0, 0, 0);
5336 screen_write_insertline(&ctx, ny, 8);
5337 window_copy_write_lines(wme, &ctx, 0, ny);
5338 if (s->sel != NULL && screen_size_y(s) > ny)
5339 window_copy_write_line(wme, &ctx, ny);
5340 else if (ny == 1) /* nuke position */
5341 window_copy_write_line(wme, &ctx, 1);
5342 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
5343 screen_write_stop(&ctx);
5344 }
5345
5346 static void
5347 window_copy_rectangle_set(struct window_mode_entry *wme, int rectflag)
5348 {
5349 struct window_copy_mode_data *data = wme->data;
5350 u_int px, py;
5351
5352 data->rectflag = rectflag;
5353
5354 py = screen_hsize(data->backing) + data->cy - data->oy;
5355 px = window_copy_find_length(wme, py);
5356 if (data->cx > px)
5357 window_copy_update_cursor(wme, px, data->cy);
5358
5359 window_copy_update_selection(wme, 1, 0);
5360 window_copy_redraw_screen(wme);
5361 }
5362
5363 static void
5364 window_copy_move_mouse(struct mouse_event *m)
5365 {
5366 struct window_pane *wp;
5367 struct window_mode_entry *wme;
5368 u_int x, y;
5369
5370 wp = cmd_mouse_pane(m, NULL, NULL);
5371 if (wp == NULL)
5372 return;
5373 wme = TAILQ_FIRST(&wp->modes);
5374 if (wme == NULL)
5375 return;
5376 if (wme->mode != &window_copy_mode && wme->mode != &window_view_mode)
5377 return;
5378
5379 if (cmd_mouse_at(wp, m, &x, &y, 0) != 0)
5380 return;
5381
5382 window_copy_update_cursor(wme, x, y);
5383 }
5384
5385 void
5386 window_copy_start_drag(struct client *c, struct mouse_event *m)
5387 {
5388 struct window_pane *wp;
5389 struct window_mode_entry *wme;
5390 struct window_copy_mode_data *data;
5391 u_int x, y, yg;
5392
5393 if (c == NULL)
5394 return;
5395
5396 wp = cmd_mouse_pane(m, NULL, NULL);
5397 if (wp == NULL)
5398 return;
5399 wme = TAILQ_FIRST(&wp->modes);
5400 if (wme == NULL)
5401 return;
5402 if (wme->mode != &window_copy_mode && wme->mode != &window_view_mode)
5403 return;
5404
5405 if (cmd_mouse_at(wp, m, &x, &y, 1) != 0)
5406 return;
5407
5408 c->tty.mouse_drag_update = window_copy_drag_update;
5409 c->tty.mouse_drag_release = window_copy_drag_release;
5410
5411 data = wme->data;
5412 yg = screen_hsize(data->backing) + y - data->oy;
5413 if (x < data->selrx || x > data->endselrx || yg != data->selry)
5414 data->selflag = SEL_CHAR;
5415 switch (data->selflag) {
5416 case SEL_WORD:
5417 if (data->separators != NULL) {
5418 window_copy_update_cursor(wme, x, y);
5419 window_copy_cursor_previous_word_pos(wme,
5420 data->separators, &x, &y);
5421 y -= screen_hsize(data->backing) - data->oy;
5422 }
5423 window_copy_update_cursor(wme, x, y);
5424 break;
5425 case SEL_LINE:
5426 window_copy_update_cursor(wme, 0, y);
5427 break;
5428 case SEL_CHAR:
5429 window_copy_update_cursor(wme, x, y);
5430 window_copy_start_selection(wme);
5431 break;
5432 }
5433
5434 window_copy_redraw_screen(wme);
5435 window_copy_drag_update(c, m);
5436 }
5437
5438 static void
5439 window_copy_drag_update(struct client *c, struct mouse_event *m)
5440 {
5441 struct window_pane *wp;
5442 struct window_mode_entry *wme;
5443 struct window_copy_mode_data *data;
5444 u_int x, y, old_cx, old_cy;
5445 struct timeval tv = {
5446 .tv_usec = WINDOW_COPY_DRAG_REPEAT_TIME
5447 };
5448
5449 if (c == NULL)
5450 return;
5451
5452 wp = cmd_mouse_pane(m, NULL, NULL);
5453 if (wp == NULL)
5454 return;
5455 wme = TAILQ_FIRST(&wp->modes);
5456 if (wme == NULL)
5457 return;
5458 if (wme->mode != &window_copy_mode && wme->mode != &window_view_mode)
5459 return;
5460
5461 data = wme->data;
5462 evtimer_del(&data->dragtimer);
5463
5464 if (cmd_mouse_at(wp, m, &x, &y, 0) != 0)
5465 return;
5466 old_cx = data->cx;
5467 old_cy = data->cy;
5468
5469 window_copy_update_cursor(wme, x, y);
5470 if (window_copy_update_selection(wme, 1, 0))
5471 window_copy_redraw_selection(wme, old_cy);
5472 if (old_cy != data->cy || old_cx == data->cx) {
5473 if (y == 0) {
5474 evtimer_add(&data->dragtimer, &tv);
5475 window_copy_cursor_up(wme, 1);
5476 } else if (y == screen_size_y(&data->screen) - 1) {
5477 evtimer_add(&data->dragtimer, &tv);
5478 window_copy_cursor_down(wme, 1);
5479 }
5480 }
5481 }
5482
5483 static void
5484 window_copy_drag_release(struct client *c, struct mouse_event *m)
5485 {
5486 struct window_pane *wp;
5487 struct window_mode_entry *wme;
5488 struct window_copy_mode_data *data;
5489
5490 if (c == NULL)
5491 return;
5492
5493 wp = cmd_mouse_pane(m, NULL, NULL);
5494 if (wp == NULL)
5495 return;
5496 wme = TAILQ_FIRST(&wp->modes);
5497 if (wme == NULL)
5498 return;
5499 if (wme->mode != &window_copy_mode && wme->mode != &window_view_mode)
5500 return;
5501
5502 data = wme->data;
5503 evtimer_del(&data->dragtimer);
5504 }
5505
5506 static void
5507 window_copy_jump_to_mark(struct window_mode_entry *wme)
5508 {
5509 struct window_copy_mode_data *data = wme->data;
5510 u_int tmx, tmy;
5511
5512 tmx = data->cx;
5513 tmy = screen_hsize(data->backing) + data->cy - data->oy;
5514 data->cx = data->mx;
5515 if (data->my < screen_hsize(data->backing)) {
5516 data->cy = 0;
5517 data->oy = screen_hsize(data->backing) - data->my;
5518 } else {
5519 data->cy = data->my - screen_hsize(data->backing);
5520 data->oy = 0;
5521 }
5522 data->mx = tmx;
5523 data->my = tmy;
5524 data->showmark = 1;
5525 window_copy_update_selection(wme, 0, 0);
5526 window_copy_redraw_screen(wme);
5527 }
5528
5529 /* Scroll up if the cursor went off the visible screen. */
5530 static void
5531 window_copy_acquire_cursor_up(struct window_mode_entry *wme, u_int hsize,
5532 u_int oy, u_int oldy, u_int px, u_int py)
5533 {
5534 u_int cy, yy, ny, nd;
5535
5536 yy = hsize - oy;
5537 if (py < yy) {
5538 ny = yy - py;
5539 cy = 0;
5540 nd = 1;
5541 } else {
5542 ny = 0;
5543 cy = py - yy;
5544 nd = oldy - cy + 1;
5545 }
5546 while (ny > 0) {
5547 window_copy_cursor_up(wme, 1);
5548 ny--;
5549 }
5550 window_copy_update_cursor(wme, px, cy);
5551 if (window_copy_update_selection(wme, 1, 0))
5552 window_copy_redraw_lines(wme, cy, nd);
5553 }
5554
5555 /* Scroll down if the cursor went off the visible screen. */
5556 static void
5557 window_copy_acquire_cursor_down(struct window_mode_entry *wme, u_int hsize,
5558 u_int sy, u_int oy, u_int oldy, u_int px, u_int py, int no_reset)
5559 {
5560 u_int cy, yy, ny, nd;
5561
5562 cy = py - hsize + oy;
5563 yy = sy - 1;
5564 if (cy > yy) {
5565 ny = cy - yy;
5566 oldy = yy;
5567 nd = 1;
5568 } else {
5569 ny = 0;
5570 nd = cy - oldy + 1;
5571 }
5572 while (ny > 0) {
5573 window_copy_cursor_down(wme, 1);
5574 ny--;
5575 }
5576 if (cy > yy)
5577 window_copy_update_cursor(wme, px, yy);
5578 else
5579 window_copy_update_cursor(wme, px, cy);
5580 if (window_copy_update_selection(wme, 1, no_reset))
5581 window_copy_redraw_lines(wme, oldy, nd);
5582 }