?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't return if in the current window since we may want to report a bell
[tmux-openbsd.git] / window-copy.c
blob3324fed37de7f996151ba3c7fda524a659c1fff2
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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 <stdlib.h>
22 #include <string.h>
23
24 #include "tmux.h"
25
26 struct screen *window_copy_init(struct window_pane *);
27 void window_copy_free(struct window_pane *);
28 void window_copy_resize(struct window_pane *, u_int, u_int);
29 void window_copy_key(struct window_pane *, struct session *, int);
30 int window_copy_key_input(struct window_pane *, int);
31 int window_copy_key_numeric_prefix(struct window_pane *, int);
32 void window_copy_mouse(
33 struct window_pane *, struct session *, struct mouse_event *);
34
35 void window_copy_redraw_lines(struct window_pane *, u_int, u_int);
36 void window_copy_redraw_screen(struct window_pane *);
37 void window_copy_write_line(
38 struct window_pane *, struct screen_write_ctx *, u_int);
39 void window_copy_write_lines(
40 struct window_pane *, struct screen_write_ctx *, u_int, u_int);
41
42 void window_copy_scroll_to(struct window_pane *, u_int, u_int);
43 int window_copy_search_compare(
44 struct grid *, u_int, u_int, struct grid *, u_int);
45 int window_copy_search_lr(
46 struct grid *, struct grid *, u_int *, u_int, u_int, u_int);
47 int window_copy_search_rl(
48 struct grid *, struct grid *, u_int *, u_int, u_int, u_int);
49 void window_copy_search_up(struct window_pane *, const char *);
50 void window_copy_search_down(struct window_pane *, const char *);
51 void window_copy_goto_line(struct window_pane *, const char *);
52 void window_copy_update_cursor(struct window_pane *, u_int, u_int);
53 void window_copy_start_selection(struct window_pane *);
54 int window_copy_update_selection(struct window_pane *);
55 void window_copy_copy_selection(struct window_pane *, struct session *);
56 void window_copy_clear_selection(struct window_pane *);
57 void window_copy_copy_line(
58 struct window_pane *, char **, size_t *, u_int, u_int, u_int);
59 int window_copy_in_set(struct window_pane *, u_int, u_int, const char *);
60 u_int window_copy_find_length(struct window_pane *, u_int);
61 void window_copy_cursor_start_of_line(struct window_pane *);
62 void window_copy_cursor_back_to_indentation(struct window_pane *);
63 void window_copy_cursor_end_of_line(struct window_pane *);
64 void window_copy_cursor_left(struct window_pane *);
65 void window_copy_cursor_right(struct window_pane *);
66 void window_copy_cursor_up(struct window_pane *, int);
67 void window_copy_cursor_down(struct window_pane *, int);
68 void window_copy_cursor_jump(struct window_pane *);
69 void window_copy_cursor_jump_back(struct window_pane *);
70 void window_copy_cursor_next_word(struct window_pane *, const char *);
71 void window_copy_cursor_next_word_end(struct window_pane *, const char *);
72 void window_copy_cursor_previous_word(struct window_pane *, const char *);
73 void window_copy_scroll_up(struct window_pane *, u_int);
74 void window_copy_scroll_down(struct window_pane *, u_int);
75 void window_copy_rectangle_toggle(struct window_pane *);
76
77 const struct window_mode window_copy_mode = {
78 window_copy_init,
79 window_copy_free,
80 window_copy_resize,
81 window_copy_key,
82 window_copy_mouse,
83 NULL,
84 };
85
86 enum window_copy_input_type {
87 WINDOW_COPY_OFF,
88 WINDOW_COPY_NUMERICPREFIX,
89 WINDOW_COPY_SEARCHUP,
90 WINDOW_COPY_SEARCHDOWN,
91 WINDOW_COPY_JUMPFORWARD,
92 WINDOW_COPY_JUMPBACK,
93 WINDOW_COPY_GOTOLINE,
94 };
95
96 /*
97 * Copy-mode's visible screen (the "screen" field) is filled from one of
98 * two sources: the original contents of the pane (used when we
99 * actually enter via the "copy-mode" command, to copy the contents of
100 * the current pane), or else a series of lines containing the output
101 * from an output-writing tmux command (such as any of the "show-*" or
102 * "list-*" commands).
103 *
104 * In either case, the full content of the copy-mode grid is pointed at
105 * by the "backing" field, and is copied into "screen" as needed (that
106 * is, when scrolling occurs). When copy-mode is backed by a pane,
107 * backing points directly at that pane's screen structure (&wp->base);
108 * when backed by a list of output-lines from a command, it points at
109 * a newly-allocated screen structure (which is deallocated when the
110 * mode ends).
111 */
112 struct window_copy_mode_data {
113 struct screen screen;
114
115 struct screen *backing;
116 int backing_written; /* backing display has started */
117
118 struct mode_key_data mdata;
119
120 u_int oy;
121
122 u_int selx;
123 u_int sely;
124
125 u_int rectflag; /* are we in rectangle copy mode? */
126
127 u_int cx;
128 u_int cy;
129
130 u_int lastcx; /* position in last line with content */
131 u_int lastsx; /* size of last line with content */
132
133 enum window_copy_input_type inputtype;
134 const char *inputprompt;
135 char *inputstr;
136
137 u_int numprefix;
138
139 enum window_copy_input_type searchtype;
140 char *searchstr;
141
142 enum window_copy_input_type jumptype;
143 char jumpchar;
144 };
145
146 struct screen *
147 window_copy_init(struct window_pane *wp)
148 {
149 struct window_copy_mode_data *data;
150 struct screen *s;
151 int keys;
152
153 wp->modedata = data = xmalloc(sizeof *data);
154 data->oy = 0;
155 data->cx = 0;
156 data->cy = 0;
157
158 data->lastcx = 0;
159 data->lastsx = 0;
160
161 data->backing_written = 0;
162
163 data->rectflag = 0;
164
165 data->inputtype = WINDOW_COPY_OFF;
166 data->inputprompt = NULL;
167 data->inputstr = xstrdup("");
168 data->numprefix = 0;
169
170 data->searchtype = WINDOW_COPY_OFF;
171 data->searchstr = NULL;
172
173 wp->flags |= PANE_FREEZE;
174 bufferevent_disable(wp->event, EV_READ|EV_WRITE);
175
176 data->jumptype = WINDOW_COPY_OFF;
177 data->jumpchar = '\0';
178
179 s = &data->screen;
180 screen_init(s, screen_size_x(&wp->base), screen_size_y(&wp->base), 0);
181 if (options_get_number(&wp->window->options, "mode-mouse"))
182 s->mode |= MODE_MOUSE;
183
184 keys = options_get_number(&wp->window->options, "mode-keys");
185 if (keys == MODEKEY_EMACS)
186 mode_key_init(&data->mdata, &mode_key_tree_emacs_copy);
187 else
188 mode_key_init(&data->mdata, &mode_key_tree_vi_copy);
189
190 data->backing = NULL;
191
192 return (s);
193 }
194
195 void
196 window_copy_init_from_pane(struct window_pane *wp)
197 {
198 struct window_copy_mode_data *data = wp->modedata;
199 struct screen *s = &data->screen;
200 struct screen_write_ctx ctx;
201 u_int i;
202
203 if (wp->mode != &window_copy_mode)
204 fatalx("not in copy mode");
205
206 data->backing = &wp->base;
207 data->cx = data->backing->cx;
208 data->cy = data->backing->cy;
209
210 s->cx = data->cx;
211 s->cy = data->cy;
212
213 screen_write_start(&ctx, NULL, s);
214 for (i = 0; i < screen_size_y(s); i++)
215 window_copy_write_line(wp, &ctx, i);
216 screen_write_cursormove(&ctx, data->cx, data->cy);
217 screen_write_stop(&ctx);
218 }
219
220 void
221 window_copy_init_for_output(struct window_pane *wp)
222 {
223 struct window_copy_mode_data *data = wp->modedata;
224
225 data->backing = xmalloc(sizeof *data->backing);
226 screen_init(data->backing, screen_size_x(&wp->base),
227 screen_size_y(&wp->base), UINT_MAX);
228 data->backing->mode &= ~MODE_WRAP;
229 }
230
231 void
232 window_copy_free(struct window_pane *wp)
233 {
234 struct window_copy_mode_data *data = wp->modedata;
235
236 wp->flags &= ~PANE_FREEZE;
237 bufferevent_enable(wp->event, EV_READ|EV_WRITE);
238
239 if (data->searchstr != NULL)
240 xfree(data->searchstr);
241 xfree(data->inputstr);
242
243 if (data->backing != &wp->base) {
244 screen_free(data->backing);
245 xfree(data->backing);
246 }
247 screen_free(&data->screen);
248
249 xfree(data);
250 }
251
252 void
253 window_copy_add(struct window_pane *wp, const char *fmt, ...)
254 {
255 va_list ap;
256
257 va_start(ap, fmt);
258 window_copy_vadd(wp, fmt, ap);
259 va_end(ap);
260 }
261
262 void
263 window_copy_vadd(struct window_pane *wp, const char *fmt, va_list ap)
264 {
265 struct window_copy_mode_data *data = wp->modedata;
266 struct screen *backing = data->backing;
267 struct screen_write_ctx back_ctx, ctx;
268 struct grid_cell gc;
269 int utf8flag;
270 u_int old_hsize;
271
272 if (backing == &wp->base)
273 return;
274
275 utf8flag = options_get_number(&wp->window->options, "utf8");
276 memcpy(&gc, &grid_default_cell, sizeof gc);
277
278 old_hsize = screen_hsize(data->backing);
279 screen_write_start(&back_ctx, NULL, backing);
280 if (data->backing_written) {
281 /*
282 * On the second or later line, do a CRLF before writing
283 * (so it's on a new line).
284 */
285 screen_write_carriagereturn(&back_ctx);
286 screen_write_linefeed(&back_ctx, 0);
287 } else
288 data->backing_written = 1;
289 screen_write_vnputs(&back_ctx, 0, &gc, utf8flag, fmt, ap);
290 screen_write_stop(&back_ctx);
291
292 data->oy += screen_hsize(data->backing) - old_hsize;
293
294 screen_write_start(&ctx, wp, &data->screen);
295
296 /*
297 * If the history has changed, draw the top line.
298 * (If there's any history at all, it has changed.)
299 */
300 if (screen_hsize(data->backing))
301 window_copy_redraw_lines(wp, 0, 1);
302
303 /* Write the line, if it's visible. */
304 if (backing->cy + data->oy < screen_size_y(backing))
305 window_copy_redraw_lines(wp, backing->cy, 1);
306
307 screen_write_stop(&ctx);
308 }
309
310 void
311 window_copy_pageup(struct window_pane *wp)
312 {
313 struct window_copy_mode_data *data = wp->modedata;
314 struct screen *s = &data->screen;
315 u_int n;
316
317 n = 1;
318 if (screen_size_y(s) > 2)
319 n = screen_size_y(s) - 2;
320 if (data->oy + n > screen_hsize(data->backing))
321 data->oy = screen_hsize(data->backing);
322 else
323 data->oy += n;
324 window_copy_update_selection(wp);
325 window_copy_redraw_screen(wp);
326 }
327
328 void
329 window_copy_resize(struct window_pane *wp, u_int sx, u_int sy)
330 {
331 struct window_copy_mode_data *data = wp->modedata;
332 struct screen *s = &data->screen;
333 struct screen_write_ctx ctx;
334
335 screen_resize(s, sx, sy);
336 if (data->backing != &wp->base)
337 screen_resize(data->backing, sx, sy);
338
339 if (data->cy > sy - 1)
340 data->cy = sy - 1;
341 if (data->cx > sx)
342 data->cx = sx;
343
344 window_copy_clear_selection(wp);
345
346 screen_write_start(&ctx, NULL, s);
347 window_copy_write_lines(wp, &ctx, 0, screen_size_y(s) - 1);
348 screen_write_stop(&ctx);
349
350 window_copy_redraw_screen(wp);
351 }
352
353 void
354 window_copy_key(struct window_pane *wp, struct session *sess, int key)
355 {
356 const char *word_separators;
357 struct window_copy_mode_data *data = wp->modedata;
358 struct screen *s = &data->screen;
359 u_int n, np;
360 int keys;
361 enum mode_key_cmd cmd;
362
363 np = data->numprefix;
364 if (np == 0)
365 np = 1;
366
367 if (data->inputtype == WINDOW_COPY_JUMPFORWARD
368 || data->inputtype == WINDOW_COPY_JUMPBACK) {
369 /* Ignore keys with modifiers. */
370 if ((key & KEYC_MASK_MOD) == 0) {
371 data->jumpchar = key;
372 if (data->inputtype == WINDOW_COPY_JUMPFORWARD) {
373 for (; np != 0; np--)
374 window_copy_cursor_jump(wp);
375 } else {
376 for (; np != 0; np--)
377 window_copy_cursor_jump_back(wp);
378 }
379 }
380 data->jumptype = data->inputtype;
381 data->inputtype = WINDOW_COPY_OFF;
382 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
383 return;
384 } if (data->inputtype == WINDOW_COPY_NUMERICPREFIX) {
385 if (window_copy_key_numeric_prefix(wp, key) == 0)
386 return;
387 data->inputtype = WINDOW_COPY_OFF;
388 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
389 } else if (data->inputtype != WINDOW_COPY_OFF) {
390 if (window_copy_key_input(wp, key) != 0)
391 goto input_off;
392 return;
393 }
394
395 cmd = mode_key_lookup(&data->mdata, key);
396 switch (cmd) {
397 case MODEKEYCOPY_CANCEL:
398 window_pane_reset_mode(wp);
399 return;
400 case MODEKEYCOPY_LEFT:
401 for (; np != 0; np--)
402 window_copy_cursor_left(wp);
403 break;
404 case MODEKEYCOPY_RIGHT:
405 for (; np != 0; np--)
406 window_copy_cursor_right(wp);
407 break;
408 case MODEKEYCOPY_UP:
409 for (; np != 0; np--)
410 window_copy_cursor_up(wp, 0);
411 break;
412 case MODEKEYCOPY_DOWN:
413 for (; np != 0; np--)
414 window_copy_cursor_down(wp, 0);
415 break;
416 case MODEKEYCOPY_SCROLLUP:
417 for (; np != 0; np--)
418 window_copy_cursor_up(wp, 1);
419 break;
420 case MODEKEYCOPY_SCROLLDOWN:
421 for (; np != 0; np--)
422 window_copy_cursor_down(wp, 1);
423 break;
424 case MODEKEYCOPY_PREVIOUSPAGE:
425 for (; np != 0; np--)
426 window_copy_pageup(wp);
427 break;
428 case MODEKEYCOPY_NEXTPAGE:
429 n = 1;
430 if (screen_size_y(s) > 2)
431 n = screen_size_y(s) - 2;
432 for (; np != 0; np--) {
433 if (data->oy < n)
434 data->oy = 0;
435 else
436 data->oy -= n;
437 }
438 window_copy_update_selection(wp);
439 window_copy_redraw_screen(wp);
440 break;
441 case MODEKEYCOPY_HALFPAGEUP:
442 n = screen_size_y(s) / 2;
443 for (; np != 0; np--) {
444 if (data->oy + n > screen_hsize(data->backing))
445 data->oy = screen_hsize(data->backing);
446 else
447 data->oy += n;
448 }
449 window_copy_update_selection(wp);
450 window_copy_redraw_screen(wp);
451 break;
452 case MODEKEYCOPY_HALFPAGEDOWN:
453 n = screen_size_y(s) / 2;
454 for (; np != 0; np--) {
455 if (data->oy < n)
456 data->oy = 0;
457 else
458 data->oy -= n;
459 }
460 window_copy_update_selection(wp);
461 window_copy_redraw_screen(wp);
462 break;
463 case MODEKEYCOPY_TOPLINE:
464 data->cx = 0;
465 data->cy = 0;
466 window_copy_update_selection(wp);
467 window_copy_redraw_screen(wp);
468 break;
469 case MODEKEYCOPY_MIDDLELINE:
470 data->cx = 0;
471 data->cy = (screen_size_y(s) - 1) / 2;
472 window_copy_update_selection(wp);
473 window_copy_redraw_screen(wp);
474 break;
475 case MODEKEYCOPY_BOTTOMLINE:
476 data->cx = 0;
477 data->cy = screen_size_y(s) - 1;
478 window_copy_update_selection(wp);
479 window_copy_redraw_screen(wp);
480 break;
481 case MODEKEYCOPY_HISTORYTOP:
482 data->cx = 0;
483 data->cy = 0;
484 data->oy = screen_hsize(data->backing);
485 window_copy_update_selection(wp);
486 window_copy_redraw_screen(wp);
487 break;
488 case MODEKEYCOPY_HISTORYBOTTOM:
489 data->cx = 0;
490 data->cy = screen_size_y(s) - 1;
491 data->oy = 0;
492 window_copy_update_selection(wp);
493 window_copy_redraw_screen(wp);
494 break;
495 case MODEKEYCOPY_STARTSELECTION:
496 window_copy_start_selection(wp);
497 window_copy_redraw_screen(wp);
498 break;
499 case MODEKEYCOPY_CLEARSELECTION:
500 window_copy_clear_selection(wp);
501 window_copy_redraw_screen(wp);
502 break;
503 case MODEKEYCOPY_COPYSELECTION:
504 if (sess != NULL) {
505 window_copy_copy_selection(wp, sess);
506 window_pane_reset_mode(wp);
507 return;
508 }
509 break;
510 case MODEKEYCOPY_STARTOFLINE:
511 window_copy_cursor_start_of_line(wp);
512 break;
513 case MODEKEYCOPY_BACKTOINDENTATION:
514 window_copy_cursor_back_to_indentation(wp);
515 break;
516 case MODEKEYCOPY_ENDOFLINE:
517 window_copy_cursor_end_of_line(wp);
518 break;
519 case MODEKEYCOPY_NEXTSPACE:
520 for (; np != 0; np--)
521 window_copy_cursor_next_word(wp, " ");
522 break;
523 case MODEKEYCOPY_NEXTSPACEEND:
524 for (; np != 0; np--)
525 window_copy_cursor_next_word_end(wp, " ");
526 break;
527 case MODEKEYCOPY_NEXTWORD:
528 word_separators =
529 options_get_string(&wp->window->options, "word-separators");
530 for (; np != 0; np--)
531 window_copy_cursor_next_word(wp, word_separators);
532 break;
533 case MODEKEYCOPY_NEXTWORDEND:
534 word_separators =
535 options_get_string(&wp->window->options, "word-separators");
536 for (; np != 0; np--)
537 window_copy_cursor_next_word_end(wp, word_separators);
538 break;
539 case MODEKEYCOPY_PREVIOUSSPACE:
540 for (; np != 0; np--)
541 window_copy_cursor_previous_word(wp, " ");
542 break;
543 case MODEKEYCOPY_PREVIOUSWORD:
544 word_separators =
545 options_get_string(&wp->window->options, "word-separators");
546 for (; np != 0; np--)
547 window_copy_cursor_previous_word(wp, word_separators);
548 break;
549 case MODEKEYCOPY_JUMP:
550 data->inputtype = WINDOW_COPY_JUMPFORWARD;
551 data->inputprompt = "Jump Forward";
552 *data->inputstr = '\0';
553 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
554 return; /* skip numprefix reset */
555 case MODEKEYCOPY_JUMPAGAIN:
556 if (data->jumptype == WINDOW_COPY_JUMPFORWARD) {
557 for (; np != 0; np--)
558 window_copy_cursor_jump(wp);
559 } else if (data->jumptype == WINDOW_COPY_JUMPBACK) {
560 for (; np != 0; np--)
561 window_copy_cursor_jump_back(wp);
562 }
563 break;
564 case MODEKEYCOPY_JUMPREVERSE:
565 if (data->jumptype == WINDOW_COPY_JUMPFORWARD) {
566 for (; np != 0; np--)
567 window_copy_cursor_jump_back(wp);
568 } else if (data->jumptype == WINDOW_COPY_JUMPBACK) {
569 for (; np != 0; np--)
570 window_copy_cursor_jump(wp);
571 }
572 break;
573 case MODEKEYCOPY_JUMPBACK:
574 data->inputtype = WINDOW_COPY_JUMPBACK;
575 data->inputprompt = "Jump Back";
576 *data->inputstr = '\0';
577 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
578 return; /* skip numprefix reset */
579 case MODEKEYCOPY_SEARCHUP:
580 data->inputtype = WINDOW_COPY_SEARCHUP;
581 data->inputprompt = "Search Up";
582 goto input_on;
583 case MODEKEYCOPY_SEARCHDOWN:
584 data->inputtype = WINDOW_COPY_SEARCHDOWN;
585 data->inputprompt = "Search Down";
586 goto input_on;
587 case MODEKEYCOPY_SEARCHAGAIN:
588 case MODEKEYCOPY_SEARCHREVERSE:
589 switch (data->searchtype) {
590 case WINDOW_COPY_OFF:
591 case WINDOW_COPY_GOTOLINE:
592 case WINDOW_COPY_JUMPFORWARD:
593 case WINDOW_COPY_JUMPBACK:
594 case WINDOW_COPY_NUMERICPREFIX:
595 break;
596 case WINDOW_COPY_SEARCHUP:
597 if (cmd == MODEKEYCOPY_SEARCHAGAIN) {
598 for (; np != 0; np--) {
599 window_copy_search_up(
600 wp, data->searchstr);
601 }
602 } else {
603 for (; np != 0; np--) {
604 window_copy_search_down(
605 wp, data->searchstr);
606 }
607 }
608 break;
609 case WINDOW_COPY_SEARCHDOWN:
610 if (cmd == MODEKEYCOPY_SEARCHAGAIN) {
611 for (; np != 0; np--) {
612 window_copy_search_down(
613 wp, data->searchstr);
614 }
615 } else {
616 for (; np != 0; np--) {
617 window_copy_search_up(
618 wp, data->searchstr);
619 }
620 }
621 break;
622 }
623 break;
624 case MODEKEYCOPY_GOTOLINE:
625 data->inputtype = WINDOW_COPY_GOTOLINE;
626 data->inputprompt = "Goto Line";
627 *data->inputstr = '\0';
628 goto input_on;
629 case MODEKEYCOPY_STARTNUMBERPREFIX:
630 key &= KEYC_MASK_KEY;
631 if (key >= '0' && key <= '9') {
632 data->inputtype = WINDOW_COPY_NUMERICPREFIX;
633 data->numprefix = 0;
634 window_copy_key_numeric_prefix(wp, key);
635 return;
636 }
637 break;
638 case MODEKEYCOPY_RECTANGLETOGGLE:
639 window_copy_rectangle_toggle(wp);
640 break;
641 default:
642 break;
643 }
644
645 data->numprefix = 0;
646 return;
647
648 input_on:
649 keys = options_get_number(&wp->window->options, "mode-keys");
650 if (keys == MODEKEY_EMACS)
651 mode_key_init(&data->mdata, &mode_key_tree_emacs_edit);
652 else
653 mode_key_init(&data->mdata, &mode_key_tree_vi_edit);
654
655 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
656 return;
657
658 input_off:
659 keys = options_get_number(&wp->window->options, "mode-keys");
660 if (keys == MODEKEY_EMACS)
661 mode_key_init(&data->mdata, &mode_key_tree_emacs_copy);
662 else
663 mode_key_init(&data->mdata, &mode_key_tree_vi_copy);
664
665 data->inputtype = WINDOW_COPY_OFF;
666 data->inputprompt = NULL;
667
668 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
669 }
670
671 int
672 window_copy_key_input(struct window_pane *wp, int key)
673 {
674 struct window_copy_mode_data *data = wp->modedata;
675 struct screen *s = &data->screen;
676 size_t inputlen;
677 u_int np;
678
679 switch (mode_key_lookup(&data->mdata, key)) {
680 case MODEKEYEDIT_CANCEL:
681 data->numprefix = 0;
682 return (-1);
683 case MODEKEYEDIT_BACKSPACE:
684 inputlen = strlen(data->inputstr);
685 if (inputlen > 0)
686 data->inputstr[inputlen - 1] = '\0';
687 break;
688 case MODEKEYEDIT_DELETELINE:
689 *data->inputstr = '\0';
690 break;
691 case MODEKEYEDIT_ENTER:
692 np = data->numprefix;
693 if (np == 0)
694 np = 1;
695
696 switch (data->inputtype) {
697 case WINDOW_COPY_OFF:
698 case WINDOW_COPY_JUMPFORWARD:
699 case WINDOW_COPY_JUMPBACK:
700 case WINDOW_COPY_NUMERICPREFIX:
701 break;
702 case WINDOW_COPY_SEARCHUP:
703 for (; np != 0; np--)
704 window_copy_search_up(wp, data->inputstr);
705 data->searchtype = data->inputtype;
706 data->searchstr = xstrdup(data->inputstr);
707 break;
708 case WINDOW_COPY_SEARCHDOWN:
709 for (; np != 0; np--)
710 window_copy_search_down(wp, data->inputstr);
711 data->searchtype = data->inputtype;
712 data->searchstr = xstrdup(data->inputstr);
713 break;
714 case WINDOW_COPY_GOTOLINE:
715 window_copy_goto_line(wp, data->inputstr);
716 *data->inputstr = '\0';
717 break;
718 }
719 data->numprefix = 0;
720 return (1);
721 case MODEKEY_OTHER:
722 if (key < 32 || key > 126)
723 break;
724 inputlen = strlen(data->inputstr) + 2;
725
726 data->inputstr = xrealloc(data->inputstr, 1, inputlen);
727 data->inputstr[inputlen - 2] = key;
728 data->inputstr[inputlen - 1] = '\0';
729 break;
730 default:
731 break;
732 }
733
734 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
735 return (0);
736 }
737
738 int
739 window_copy_key_numeric_prefix(struct window_pane *wp, int key)
740 {
741 struct window_copy_mode_data *data = wp->modedata;
742 struct screen *s = &data->screen;
743
744 key &= KEYC_MASK_KEY;
745 if (key < '0' || key > '9')
746 return 1;
747
748 if (data->numprefix >= 100) /* no more than three digits */
749 return 0;
750 data->numprefix = data->numprefix * 10 + key - '0';
751
752 window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
753 return 0;
754 }
755
756 /* ARGSUSED */
757 void
758 window_copy_mouse(
759 struct window_pane *wp, unused struct session *sess, struct mouse_event *m)
760 {
761 struct window_copy_mode_data *data = wp->modedata;
762 struct screen *s = &data->screen;
763 u_int i;
764
765 if (m->x >= screen_size_x(s))
766 return;
767 if (m->y >= screen_size_y(s))
768 return;
769
770 /* If mouse wheel (buttons 4 and 5), scroll. */
771 if ((m->b & MOUSE_45)) {
772 if ((m->b & MOUSE_BUTTON) == MOUSE_1) {
773 for (i = 0; i < 5; i++)
774 window_copy_cursor_up(wp, 0);
775 } else if ((m->b & MOUSE_BUTTON) == MOUSE_2) {
776 for (i = 0; i < 5; i++)
777 window_copy_cursor_down(wp, 0);
778 }
779 return;
780 }
781
782 /*
783 * If already reading motion, move the cursor while buttons are still
784 * pressed, or stop the selection on their release.
785 */
786 if (s->mode & MODE_MOUSEMOTION) {
787 if ((m->b & MOUSE_BUTTON) != MOUSE_UP) {
788 window_copy_update_cursor(wp, m->x, m->y);
789 if (window_copy_update_selection(wp))
790 window_copy_redraw_screen(wp);
791 } else {
792 s->mode &= ~MODE_MOUSEMOTION;
793 if (sess != NULL) {
794 window_copy_copy_selection(wp, sess);
795 window_pane_reset_mode(wp);
796 }
797 }
798 return;
799 }
800
801 /* Otherwise i other buttons pressed, start selection and motion. */
802 if ((m->b & MOUSE_BUTTON) != MOUSE_UP) {
803 s->mode |= MODE_MOUSEMOTION;
804
805 window_copy_update_cursor(wp, m->x, m->y);
806 window_copy_start_selection(wp);
807 window_copy_redraw_screen(wp);
808 }
809 }
810
811 void
812 window_copy_scroll_to(struct window_pane *wp, u_int px, u_int py)
813 {
814 struct window_copy_mode_data *data = wp->modedata;
815 struct grid *gd = data->backing->grid;
816 u_int offset, gap;
817
818 data->cx = px;
819
820 gap = gd->sy / 4;
821 if (py < gd->sy) {
822 offset = 0;
823 data->cy = py;
824 } else if (py > gd->hsize + gd->sy - gap) {
825 offset = gd->hsize;
826 data->cy = py - gd->hsize;
827 } else {
828 offset = py + gap - gd->sy;
829 data->cy = py - offset;
830 }
831 data->oy = gd->hsize - offset;
832
833 window_copy_update_selection(wp);
834 window_copy_redraw_screen(wp);
835 }
836
837 int
838 window_copy_search_compare(
839 struct grid *gd, u_int px, u_int py, struct grid *sgd, u_int spx)
840 {
841 const struct grid_cell *gc, *sgc;
842 const struct grid_utf8 *gu, *sgu;
843
844 gc = grid_peek_cell(gd, px, py);
845 sgc = grid_peek_cell(sgd, spx, 0);
846
847 if ((gc->flags & GRID_FLAG_UTF8) != (sgc->flags & GRID_FLAG_UTF8))
848 return (0);
849
850 if (gc->flags & GRID_FLAG_UTF8) {
851 gu = grid_peek_utf8(gd, px, py);
852 sgu = grid_peek_utf8(sgd, spx, 0);
853 if (grid_utf8_compare(gu, sgu))
854 return (1);
855 } else {
856 if (gc->data == sgc->data)
857 return (1);
858 }
859 return (0);
860 }
861
862 int
863 window_copy_search_lr(struct grid *gd,
864 struct grid *sgd, u_int *ppx, u_int py, u_int first, u_int last)
865 {
866 u_int ax, bx, px;
867
868 for (ax = first; ax < last; ax++) {
869 if (ax + sgd->sx >= gd->sx)
870 break;
871 for (bx = 0; bx < sgd->sx; bx++) {
872 px = ax + bx;
873 if (!window_copy_search_compare(gd, px, py, sgd, bx))
874 break;
875 }
876 if (bx == sgd->sx) {
877 *ppx = ax;
878 return (1);
879 }
880 }
881 return (0);
882 }
883
884 int
885 window_copy_search_rl(struct grid *gd,
886 struct grid *sgd, u_int *ppx, u_int py, u_int first, u_int last)
887 {
888 u_int ax, bx, px;
889
890 for (ax = last + 1; ax > first; ax--) {
891 if (gd->sx - (ax - 1) < sgd->sx)
892 continue;
893 for (bx = 0; bx < sgd->sx; bx++) {
894 px = ax - 1 + bx;
895 if (!window_copy_search_compare(gd, px, py, sgd, bx))
896 break;
897 }
898 if (bx == sgd->sx) {
899 *ppx = ax - 1;
900 return (1);
901 }
902 }
903 return (0);
904 }
905
906 void
907 window_copy_search_up(struct window_pane *wp, const char *searchstr)
908 {
909 struct window_copy_mode_data *data = wp->modedata;
910 struct screen *s = data->backing, ss;
911 struct screen_write_ctx ctx;
912 struct grid *gd = s->grid, *sgd;
913 struct grid_cell gc;
914 size_t searchlen;
915 u_int i, last, fx, fy, px;
916 int utf8flag, n, wrapped;
917
918 if (*searchstr == '\0')
919 return;
920 utf8flag = options_get_number(&wp->window->options, "utf8");
921 searchlen = screen_write_strlen(utf8flag, "%s", searchstr);
922
923 screen_init(&ss, searchlen, 1, 0);
924 screen_write_start(&ctx, NULL, &ss);
925 memcpy(&gc, &grid_default_cell, sizeof gc);
926 screen_write_nputs(&ctx, -1, &gc, utf8flag, "%s", searchstr);
927 screen_write_stop(&ctx);
928
929 fx = data->cx;
930 fy = gd->hsize - data->oy + data->cy;
931
932 if (fx == 0) {
933 if (fy == 0)
934 return;
935 fx = gd->sx - 1;
936 fy--;
937 } else
938 fx--;
939 n = wrapped = 0;
940
941 retry:
942 sgd = ss.grid;
943 for (i = fy + 1; i > 0; i--) {
944 last = screen_size_x(s);
945 if (i == fy + 1)
946 last = fx;
947 n = window_copy_search_rl(gd, sgd, &px, i - 1, 0, last);
948 if (n) {
949 window_copy_scroll_to(wp, px, i - 1);
950 break;
951 }
952 }
953 if (!n && !wrapped) {
954 fx = gd->sx - 1;
955 fy = gd->hsize + gd->sy - 1;
956 wrapped = 1;
957 goto retry;
958 }
959
960 screen_free(&ss);
961 }
962
963 void
964 window_copy_search_down(struct window_pane *wp, const char *searchstr)
965 {
966 struct window_copy_mode_data *data = wp->modedata;
967 struct screen *s = data->backing, ss;
968 struct screen_write_ctx ctx;
969 struct grid *gd = s->grid, *sgd;
970 struct grid_cell gc;
971 size_t searchlen;
972 u_int i, first, fx, fy, px;
973 int utf8flag, n, wrapped;
974
975 if (*searchstr == '\0')
976 return;
977 utf8flag = options_get_number(&wp->window->options, "utf8");
978 searchlen = screen_write_strlen(utf8flag, "%s", searchstr);
979
980 screen_init(&ss, searchlen, 1, 0);
981 screen_write_start(&ctx, NULL, &ss);
982 memcpy(&gc, &grid_default_cell, sizeof gc);
983 screen_write_nputs(&ctx, -1, &gc, utf8flag, "%s", searchstr);
984 screen_write_stop(&ctx);
985
986 fx = data->cx;
987 fy = gd->hsize - data->oy + data->cy;
988
989 if (fx == gd->sx - 1) {
990 if (fy == gd->hsize + gd->sy)
991 return;
992 fx = 0;
993 fy++;
994 } else
995 fx++;
996 n = wrapped = 0;
997
998 retry:
999 sgd = ss.grid;
1000 for (i = fy + 1; i < gd->hsize + gd->sy; i++) {
1001 first = 0;
1002 if (i == fy + 1)
1003 first = fx;
1004 n = window_copy_search_lr(gd, sgd, &px, i - 1, first, gd->sx);
1005 if (n) {
1006 window_copy_scroll_to(wp, px, i - 1);
1007 break;
1008 }
1009 }
1010 if (!n && !wrapped) {
1011 fx = 0;
1012 fy = 0;
1013 wrapped = 1;
1014 goto retry;
1015 }
1016
1017 screen_free(&ss);
1018 }
1019
1020 void
1021 window_copy_goto_line(struct window_pane *wp, const char *linestr)
1022 {
1023 struct window_copy_mode_data *data = wp->modedata;
1024 const char *errstr;
1025 u_int lineno;
1026
1027 lineno = strtonum(linestr, 0, screen_hsize(data->backing), &errstr);
1028 if (errstr != NULL)
1029 return;
1030
1031 data->oy = lineno;
1032 window_copy_update_selection(wp);
1033 window_copy_redraw_screen(wp);
1034 }
1035
1036 void
1037 window_copy_write_line(
1038 struct window_pane *wp, struct screen_write_ctx *ctx, u_int py)
1039 {
1040 struct window_copy_mode_data *data = wp->modedata;
1041 struct screen *s = &data->screen;
1042 struct options *oo = &wp->window->options;
1043 struct grid_cell gc;
1044 char hdr[32];
1045 size_t last, xoff = 0, size = 0;
1046
1047 memcpy(&gc, &grid_default_cell, sizeof gc);
1048 colour_set_fg(&gc, options_get_number(oo, "mode-fg"));
1049 colour_set_bg(&gc, options_get_number(oo, "mode-bg"));
1050 gc.attr |= options_get_number(oo, "mode-attr");
1051
1052 last = screen_size_y(s) - 1;
1053 if (py == 0) {
1054 size = xsnprintf(hdr, sizeof hdr,
1055 "[%u/%u]", data->oy, screen_hsize(data->backing));
1056 screen_write_cursormove(ctx, screen_size_x(s) - size, 0);
1057 screen_write_puts(ctx, &gc, "%s", hdr);
1058 } else if (py == last && data->inputtype != WINDOW_COPY_OFF) {
1059 if (data->inputtype == WINDOW_COPY_NUMERICPREFIX) {
1060 xoff = size = xsnprintf(hdr, sizeof hdr,
1061 "Repeat: %u", data->numprefix);
1062 } else {
1063 xoff = size = xsnprintf(hdr, sizeof hdr,
1064 "%s: %s", data->inputprompt, data->inputstr);
1065 }
1066 screen_write_cursormove(ctx, 0, last);
1067 screen_write_puts(ctx, &gc, "%s", hdr);
1068 } else
1069 size = 0;
1070
1071 screen_write_cursormove(ctx, xoff, py);
1072 screen_write_copy(ctx, data->backing, xoff,
1073 (screen_hsize(data->backing) - data->oy) + py,
1074 screen_size_x(s) - size, 1);
1075
1076 if (py == data->cy && data->cx == screen_size_x(s)) {
1077 memcpy(&gc, &grid_default_cell, sizeof gc);
1078 screen_write_cursormove(ctx, screen_size_x(s) - 1, py);
1079 screen_write_putc(ctx, &gc, '$');
1080 }
1081 }
1082
1083 void
1084 window_copy_write_lines(
1085 struct window_pane *wp, struct screen_write_ctx *ctx, u_int py, u_int ny)
1086 {
1087 u_int yy;
1088
1089 for (yy = py; yy < py + ny; yy++)
1090 window_copy_write_line(wp, ctx, py);
1091 }
1092
1093 void
1094 window_copy_redraw_lines(struct window_pane *wp, u_int py, u_int ny)
1095 {
1096 struct window_copy_mode_data *data = wp->modedata;
1097 struct screen_write_ctx ctx;
1098 u_int i;
1099
1100 screen_write_start(&ctx, wp, NULL);
1101 for (i = py; i < py + ny; i++)
1102 window_copy_write_line(wp, &ctx, i);
1103 screen_write_cursormove(&ctx, data->cx, data->cy);
1104 screen_write_stop(&ctx);
1105 }
1106
1107 void
1108 window_copy_redraw_screen(struct window_pane *wp)
1109 {
1110 struct window_copy_mode_data *data = wp->modedata;
1111
1112 window_copy_redraw_lines(wp, 0, screen_size_y(&data->screen));
1113 }
1114
1115 void
1116 window_copy_update_cursor(struct window_pane *wp, u_int cx, u_int cy)
1117 {
1118 struct window_copy_mode_data *data = wp->modedata;
1119 struct screen *s = &data->screen;
1120 struct screen_write_ctx ctx;
1121 u_int old_cx, old_cy;
1122
1123 old_cx = data->cx; old_cy = data->cy;
1124 data->cx = cx; data->cy = cy;
1125 if (old_cx == screen_size_x(s))
1126 window_copy_redraw_lines(wp, old_cy, 1);
1127 if (data->cx == screen_size_x(s))
1128 window_copy_redraw_lines(wp, data->cy, 1);
1129 else {
1130 screen_write_start(&ctx, wp, NULL);
1131 screen_write_cursormove(&ctx, data->cx, data->cy);
1132 screen_write_stop(&ctx);
1133 }
1134 }
1135
1136 void
1137 window_copy_start_selection(struct window_pane *wp)
1138 {
1139 struct window_copy_mode_data *data = wp->modedata;
1140 struct screen *s = &data->screen;
1141
1142 data->selx = data->cx;
1143 data->sely = screen_hsize(data->backing) + data->cy - data->oy;
1144
1145 s->sel.flag = 1;
1146 window_copy_update_selection(wp);
1147 }
1148
1149 int
1150 window_copy_update_selection(struct window_pane *wp)
1151 {
1152 struct window_copy_mode_data *data = wp->modedata;
1153 struct screen *s = &data->screen;
1154 struct options *oo = &wp->window->options;
1155 struct grid_cell gc;
1156 u_int sx, sy, ty, cy;
1157
1158 if (!s->sel.flag)
1159 return (0);
1160
1161 /* Set colours. */
1162 memcpy(&gc, &grid_default_cell, sizeof gc);
1163 colour_set_fg(&gc, options_get_number(oo, "mode-fg"));
1164 colour_set_bg(&gc, options_get_number(oo, "mode-bg"));
1165 gc.attr |= options_get_number(oo, "mode-attr");
1166
1167 /* Find top of screen. */
1168 ty = screen_hsize(data->backing) - data->oy;
1169
1170 /* Adjust the selection. */
1171 sx = data->selx;
1172 sy = data->sely;
1173 if (sy < ty) { /* above screen */
1174 if (!data->rectflag)
1175 sx = 0;
1176 sy = 0;
1177 } else if (sy > ty + screen_size_y(s) - 1) { /* below screen */
1178 if (!data->rectflag)
1179 sx = screen_size_x(s) - 1;
1180 sy = screen_size_y(s) - 1;
1181 } else
1182 sy -= ty;
1183 sy = screen_hsize(s) + sy;
1184
1185 screen_set_selection(s,
1186 sx, sy, data->cx, screen_hsize(s) + data->cy, data->rectflag, &gc);
1187
1188 if (data->rectflag) {
1189 /*
1190 * Can't rely on the caller to redraw the right lines for
1191 * rectangle selection - find the highest line and the number
1192 * of lines, and redraw just past that in both directions
1193 */
1194 cy = data->cy;
1195 if (sy < cy)
1196 window_copy_redraw_lines(wp, sy, cy - sy + 1);
1197 else
1198 window_copy_redraw_lines(wp, cy, sy - cy + 1);
1199 }
1200
1201 return (1);
1202 }
1203
1204 void
1205 window_copy_copy_selection(struct window_pane *wp, struct session *sess)
1206 {
1207 struct window_copy_mode_data *data = wp->modedata;
1208 struct screen *s = &data->screen;
1209 char *buf;
1210 size_t off;
1211 u_int i, xx, yy, sx, sy, ex, ey, limit;
1212 u_int firstsx, lastex, restex, restsx;
1213
1214 if (!s->sel.flag)
1215 return;
1216
1217 buf = xmalloc(1);
1218 off = 0;
1219
1220 *buf = '\0';
1221
1222 /*
1223 * The selection extends from selx,sely to (adjusted) cx,cy on
1224 * the base screen.
1225 */
1226
1227 /* Find start and end. */
1228 xx = data->cx;
1229 yy = screen_hsize(data->backing) + data->cy - data->oy;
1230 if (yy < data->sely || (yy == data->sely && xx < data->selx)) {
1231 sx = xx; sy = yy;
1232 ex = data->selx; ey = data->sely;
1233 } else {
1234 sx = data->selx; sy = data->sely;
1235 ex = xx; ey = yy;
1236 }
1237
1238 /* Trim ex to end of line. */
1239 xx = window_copy_find_length(wp, ey);
1240 if (ex > xx)
1241 ex = xx;
1242
1243 /*
1244 * Deal with rectangle-copy if necessary; four situations: start of
1245 * first line (firstsx), end of last line (lastex), start (restsx) and
1246 * end (restex) of all other lines.
1247 */
1248 xx = screen_size_x(s);
1249 if (data->rectflag) {
1250 /*
1251 * Need to ignore the column with the cursor in it, which for
1252 * rectangular copy means knowing which side the cursor is on.
1253 */
1254 if (data->selx < data->cx) {
1255 /* Selection start is on the left. */
1256 lastex = data->cx;
1257 restex = data->cx;
1258 firstsx = data->selx;
1259 restsx = data->selx;
1260 } else {
1261 /* Cursor is on the left. */
1262 lastex = data->selx + 1;
1263 restex = data->selx + 1;
1264 firstsx = data->cx + 1;
1265 restsx = data->cx + 1;
1266 }
1267 } else {
1268 /*
1269 * Like emacs, keep the top-left-most character, and drop the
1270 * bottom-right-most, regardless of copy direction.
1271 */
1272 lastex = ex;
1273 restex = xx;
1274 firstsx = sx;
1275 restsx = 0;
1276 }
1277
1278 /* Copy the lines. */
1279 if (sy == ey)
1280 window_copy_copy_line(wp, &buf, &off, sy, firstsx, lastex);
1281 else {
1282 window_copy_copy_line(wp, &buf, &off, sy, firstsx, restex);
1283 if (ey - sy > 1) {
1284 for (i = sy + 1; i < ey; i++) {
1285 window_copy_copy_line(
1286 wp, &buf, &off, i, restsx, restex);
1287 }
1288 }
1289 window_copy_copy_line(wp, &buf, &off, ey, restsx, lastex);
1290 }
1291
1292 /* Don't bother if no data. */
1293 if (off == 0) {
1294 xfree(buf);
1295 return;
1296 }
1297 off--; /* remove final \n */
1298
1299 /* Add the buffer to the stack. */
1300 limit = options_get_number(&sess->options, "buffer-limit");
1301 paste_add(&sess->buffers, buf, off, limit);
1302 }
1303
1304 void
1305 window_copy_copy_line(struct window_pane *wp,
1306 char **buf, size_t *off, u_int sy, u_int sx, u_int ex)
1307 {
1308 struct window_copy_mode_data *data = wp->modedata;
1309 struct grid *gd = data->backing->grid;
1310 const struct grid_cell *gc;
1311 const struct grid_utf8 *gu;
1312 struct grid_line *gl;
1313 u_int i, xx, wrapped = 0;
1314 size_t size;
1315
1316 if (sx > ex)
1317 return;
1318
1319 /*
1320 * Work out if the line was wrapped at the screen edge and all of it is
1321 * on screen.
1322 */
1323 gl = &gd->linedata[sy];
1324 if (gl->flags & GRID_LINE_WRAPPED && gl->cellsize <= gd->sx)
1325 wrapped = 1;
1326
1327 /* If the line was wrapped, don't strip spaces (use the full length). */
1328 if (wrapped)
1329 xx = gl->cellsize;
1330 else
1331 xx = window_copy_find_length(wp, sy);
1332 if (ex > xx)
1333 ex = xx;
1334 if (sx > xx)
1335 sx = xx;
1336
1337 if (sx < ex) {
1338 for (i = sx; i < ex; i++) {
1339 gc = grid_peek_cell(gd, i, sy);
1340 if (gc->flags & GRID_FLAG_PADDING)
1341 continue;
1342 if (!(gc->flags & GRID_FLAG_UTF8)) {
1343 *buf = xrealloc(*buf, 1, (*off) + 1);
1344 (*buf)[(*off)++] = gc->data;
1345 } else {
1346 gu = grid_peek_utf8(gd, i, sy);
1347 size = grid_utf8_size(gu);
1348 *buf = xrealloc(*buf, 1, (*off) + size);
1349 *off += grid_utf8_copy(gu, *buf + *off, size);
1350 }
1351 }
1352 }
1353
1354 /* Only add a newline if the line wasn't wrapped. */
1355 if (!wrapped || ex != xx) {
1356 *buf = xrealloc(*buf, 1, (*off) + 1);
1357 (*buf)[(*off)++] = '\n';
1358 }
1359 }
1360
1361 void
1362 window_copy_clear_selection(struct window_pane *wp)
1363 {
1364 struct window_copy_mode_data *data = wp->modedata;
1365 u_int px, py;
1366
1367 screen_clear_selection(&data->screen);
1368
1369 py = screen_hsize(data->backing) + data->cy - data->oy;
1370 px = window_copy_find_length(wp, py);
1371 if (data->cx > px)
1372 window_copy_update_cursor(wp, px, data->cy);
1373 }
1374
1375 int
1376 window_copy_in_set(struct window_pane *wp, u_int px, u_int py, const char *set)
1377 {
1378 struct window_copy_mode_data *data = wp->modedata;
1379 const struct grid_cell *gc;
1380
1381 gc = grid_peek_cell(data->backing->grid, px, py);
1382 if (gc->flags & (GRID_FLAG_PADDING|GRID_FLAG_UTF8))
1383 return (0);
1384 if (gc->data == 0x00 || gc->data == 0x7f)
1385 return (0);
1386 return (strchr(set, gc->data) != NULL);
1387 }
1388
1389 u_int
1390 window_copy_find_length(struct window_pane *wp, u_int py)
1391 {
1392 struct window_copy_mode_data *data = wp->modedata;
1393 struct screen *s = data->backing;
1394 const struct grid_cell *gc;
1395 u_int px;
1396
1397 /*
1398 * If the pane has been resized, its grid can contain old overlong
1399 * lines. grid_peek_cell does not allow accessing cells beyond the
1400 * width of the grid, and screen_write_copy treats them as spaces, so
1401 * ignore them here too.
1402 */
1403 px = s->grid->linedata[py].cellsize;
1404 if (px > screen_size_x(s))
1405 px = screen_size_x(s);
1406 while (px > 0) {
1407 gc = grid_peek_cell(s->grid, px - 1, py);
1408 if (gc->flags & GRID_FLAG_UTF8)
1409 break;
1410 if (gc->data != ' ')
1411 break;
1412 px--;
1413 }
1414 return (px);
1415 }
1416
1417 void
1418 window_copy_cursor_start_of_line(struct window_pane *wp)
1419 {
1420 struct window_copy_mode_data *data = wp->modedata;
1421 struct screen *back_s = data->backing;
1422 struct grid *gd = back_s->grid;
1423 u_int py;
1424
1425 if (data->cx == 0) {
1426 py = screen_hsize(back_s) + data->cy - data->oy;
1427 while (py > 0 && gd->linedata[py-1].flags & GRID_LINE_WRAPPED) {
1428 window_copy_cursor_up(wp, 0);
1429 py = screen_hsize(back_s) + data->cy - data->oy;
1430 }
1431 }
1432 window_copy_update_cursor(wp, 0, data->cy);
1433 if (window_copy_update_selection(wp))
1434 window_copy_redraw_lines(wp, data->cy, 1);
1435 }
1436
1437 void
1438 window_copy_cursor_back_to_indentation(struct window_pane *wp)
1439 {
1440 struct window_copy_mode_data *data = wp->modedata;
1441 u_int px, py, xx;
1442 const struct grid_cell *gc;
1443
1444 px = 0;
1445 py = screen_hsize(data->backing) + data->cy - data->oy;
1446 xx = window_copy_find_length(wp, py);
1447
1448 while (px < xx) {
1449 gc = grid_peek_cell(data->backing->grid, px, py);
1450 if (gc->flags & GRID_FLAG_UTF8)
1451 break;
1452 if (gc->data != ' ')
1453 break;
1454 px++;
1455 }
1456
1457 window_copy_update_cursor(wp, px, data->cy);
1458 if (window_copy_update_selection(wp))
1459 window_copy_redraw_lines(wp, data->cy, 1);
1460 }
1461
1462 void
1463 window_copy_cursor_end_of_line(struct window_pane *wp)
1464 {
1465 struct window_copy_mode_data *data = wp->modedata;
1466 struct screen *back_s = data->backing;
1467 struct grid *gd = back_s->grid;
1468 u_int px, py;
1469
1470 py = screen_hsize(back_s) + data->cy - data->oy;
1471 px = window_copy_find_length(wp, py);
1472
1473 if (data->cx == px) {
1474 if (data->screen.sel.flag && data->rectflag)
1475 px = screen_size_x(back_s);
1476 if (gd->linedata[py].flags & GRID_LINE_WRAPPED) {
1477 while (py < gd->sy + gd->hsize &&
1478 gd->linedata[py].flags & GRID_LINE_WRAPPED) {
1479 window_copy_cursor_down(wp, 0);
1480 py = screen_hsize(back_s)
1481 + data->cy - data->oy;
1482 }
1483 px = window_copy_find_length(wp, py);
1484 }
1485 }
1486 window_copy_update_cursor(wp, px, data->cy);
1487
1488 if (window_copy_update_selection(wp))
1489 window_copy_redraw_lines(wp, data->cy, 1);
1490 }
1491
1492 void
1493 window_copy_cursor_left(struct window_pane *wp)
1494 {
1495 struct window_copy_mode_data *data = wp->modedata;
1496
1497 if (data->cx == 0) {
1498 window_copy_cursor_up(wp, 0);
1499 window_copy_cursor_end_of_line(wp);
1500 } else {
1501 window_copy_update_cursor(wp, data->cx - 1, data->cy);
1502 if (window_copy_update_selection(wp))
1503 window_copy_redraw_lines(wp, data->cy, 1);
1504 }
1505 }
1506
1507 void
1508 window_copy_cursor_right(struct window_pane *wp)
1509 {
1510 struct window_copy_mode_data *data = wp->modedata;
1511 u_int px, py;
1512
1513 if (data->screen.sel.flag && data->rectflag)
1514 px = screen_size_x(&data->screen);
1515 else {
1516 py = screen_hsize(data->backing) + data->cy - data->oy;
1517 px = window_copy_find_length(wp, py);
1518 }
1519
1520 if (data->cx >= px) {
1521 window_copy_cursor_start_of_line(wp);
1522 window_copy_cursor_down(wp, 0);
1523 } else {
1524 window_copy_update_cursor(wp, data->cx + 1, data->cy);
1525 if (window_copy_update_selection(wp))
1526 window_copy_redraw_lines(wp, data->cy, 1);
1527 }
1528 }
1529
1530 void
1531 window_copy_cursor_up(struct window_pane *wp, int scroll_only)
1532 {
1533 struct window_copy_mode_data *data = wp->modedata;
1534 struct screen *s = &data->screen;
1535 u_int ox, oy, px, py;
1536
1537 oy = screen_hsize(data->backing) + data->cy - data->oy;
1538 ox = window_copy_find_length(wp, oy);
1539 if (ox != 0) {
1540 data->lastcx = data->cx;
1541 data->lastsx = ox;
1542 }
1543
1544 data->cx = data->lastcx;
1545 if (scroll_only || data->cy == 0) {
1546 window_copy_scroll_down(wp, 1);
1547 if (scroll_only) {
1548 if (data->cy == screen_size_y(s) - 1)
1549 window_copy_redraw_lines(wp, data->cy, 1);
1550 else
1551 window_copy_redraw_lines(wp, data->cy, 2);
1552 }
1553 } else {
1554 window_copy_update_cursor(wp, data->cx, data->cy - 1);
1555 if (window_copy_update_selection(wp)) {
1556 if (data->cy == screen_size_y(s) - 1)
1557 window_copy_redraw_lines(wp, data->cy, 1);
1558 else
1559 window_copy_redraw_lines(wp, data->cy, 2);
1560 }
1561 }
1562
1563 if (!data->screen.sel.flag || !data->rectflag) {
1564 py = screen_hsize(data->backing) + data->cy - data->oy;
1565 px = window_copy_find_length(wp, py);
1566 if ((data->cx >= data->lastsx && data->cx != px) ||
1567 data->cx > px)
1568 window_copy_cursor_end_of_line(wp);
1569 }
1570 }
1571
1572 void
1573 window_copy_cursor_down(struct window_pane *wp, int scroll_only)
1574 {
1575 struct window_copy_mode_data *data = wp->modedata;
1576 struct screen *s = &data->screen;
1577 u_int ox, oy, px, py;
1578
1579 oy = screen_hsize(data->backing) + data->cy - data->oy;
1580 ox = window_copy_find_length(wp, oy);
1581 if (ox != 0) {
1582 data->lastcx = data->cx;
1583 data->lastsx = ox;
1584 }
1585
1586 data->cx = data->lastcx;
1587 if (scroll_only || data->cy == screen_size_y(s) - 1) {
1588 window_copy_scroll_up(wp, 1);
1589 if (scroll_only && data->cy > 0)
1590 window_copy_redraw_lines(wp, data->cy - 1, 2);
1591 } else {
1592 window_copy_update_cursor(wp, data->cx, data->cy + 1);
1593 if (window_copy_update_selection(wp))
1594 window_copy_redraw_lines(wp, data->cy - 1, 2);
1595 }
1596
1597 if (!data->screen.sel.flag || !data->rectflag) {
1598 py = screen_hsize(data->backing) + data->cy - data->oy;
1599 px = window_copy_find_length(wp, py);
1600 if ((data->cx >= data->lastsx && data->cx != px) ||
1601 data->cx > px)
1602 window_copy_cursor_end_of_line(wp);
1603 }
1604 }
1605
1606 void
1607 window_copy_cursor_jump(struct window_pane *wp)
1608 {
1609 struct window_copy_mode_data *data = wp->modedata;
1610 struct screen *back_s = data->backing;
1611 const struct grid_cell *gc;
1612 uint px, py, xx;
1613
1614 px = data->cx + 1;
1615 py = screen_hsize(back_s) + data->cy - data->oy;
1616 xx = window_copy_find_length(wp, py);
1617
1618 while (px < xx) {
1619 gc = grid_peek_cell(back_s->grid, px, py);
1620 if ((gc->flags & (GRID_FLAG_PADDING|GRID_FLAG_UTF8)) == 0
1621 && gc->data == data->jumpchar) {
1622
1623 window_copy_update_cursor(wp, px, data->cy);
1624 if (window_copy_update_selection(wp))
1625 window_copy_redraw_lines(wp, data->cy, 1);
1626 return;
1627 }
1628 px++;
1629 }
1630 }
1631
1632 void
1633 window_copy_cursor_jump_back(struct window_pane *wp)
1634 {
1635 struct window_copy_mode_data *data = wp->modedata;
1636 struct screen *back_s = data->backing;
1637 const struct grid_cell *gc;
1638 uint px, py;
1639
1640 px = data->cx;
1641 py = screen_hsize(back_s) + data->cy - data->oy;
1642
1643 if (px > 0)
1644 px--;
1645
1646 for (;;) {
1647 gc = grid_peek_cell(back_s->grid, px, py);
1648 if ((gc->flags & (GRID_FLAG_PADDING|GRID_FLAG_UTF8)) == 0
1649 && gc->data == data->jumpchar) {
1650
1651 window_copy_update_cursor(wp, px, data->cy);
1652 if (window_copy_update_selection(wp))
1653 window_copy_redraw_lines(wp, data->cy, 1);
1654 return;
1655 }
1656 if (px == 0)
1657 break;
1658 px--;
1659 }
1660 }
1661
1662 void
1663 window_copy_cursor_next_word(struct window_pane *wp, const char *separators)
1664 {
1665 struct window_copy_mode_data *data = wp->modedata;
1666 struct screen *back_s = data->backing;
1667 u_int px, py, xx, yy;
1668 int expected = 0;
1669
1670 px = data->cx;
1671 py = screen_hsize(back_s) + data->cy - data->oy;
1672 xx = window_copy_find_length(wp, py);
1673 yy = screen_hsize(back_s) + screen_size_y(back_s) - 1;
1674
1675 /*
1676 * First skip past any nonword characters and then any word characters.
1677 *
1678 * expected is initially set to 0 for the former and then 1 for the
1679 * latter.
1680 */
1681 do {
1682 while (px > xx ||
1683 window_copy_in_set(wp, px, py, separators) == expected) {
1684 /* Move down if we're past the end of the line. */
1685 if (px > xx) {
1686 if (py == yy)
1687 return;
1688 window_copy_cursor_down(wp, 0);
1689 px = 0;
1690
1691 py = screen_hsize(back_s) + data->cy - data->oy;
1692 xx = window_copy_find_length(wp, py);
1693 } else
1694 px++;
1695 }
1696 expected = !expected;
1697 } while (expected == 1);
1698
1699 window_copy_update_cursor(wp, px, data->cy);
1700 if (window_copy_update_selection(wp))
1701 window_copy_redraw_lines(wp, data->cy, 1);
1702 }
1703
1704 void
1705 window_copy_cursor_next_word_end(struct window_pane *wp, const char *separators)
1706 {
1707 struct window_copy_mode_data *data = wp->modedata;
1708 struct screen *back_s = data->backing;
1709 u_int px, py, xx, yy;
1710 int expected = 1;
1711
1712 px = data->cx;
1713 py = screen_hsize(back_s) + data->cy - data->oy;
1714 xx = window_copy_find_length(wp, py);
1715 yy = screen_hsize(back_s) + screen_size_y(back_s) - 1;
1716
1717 /*
1718 * First skip past any word characters, then any nonword characters.
1719 *
1720 * expected is initially set to 1 for the former and then 0 for the
1721 * latter.
1722 */
1723 do {
1724 while (px > xx ||
1725 window_copy_in_set(wp, px, py, separators) == expected) {
1726 /* Move down if we're past the end of the line. */
1727 if (px > xx) {
1728 if (py == yy)
1729 return;
1730 window_copy_cursor_down(wp, 0);
1731 px = 0;
1732
1733 py = screen_hsize(back_s) + data->cy - data->oy;
1734 xx = window_copy_find_length(wp, py);
1735 } else
1736 px++;
1737 }
1738 expected = !expected;
1739 } while (expected == 0);
1740
1741 window_copy_update_cursor(wp, px, data->cy);
1742 if (window_copy_update_selection(wp))
1743 window_copy_redraw_lines(wp, data->cy, 1);
1744 }
1745
1746 /* Move to the previous place where a word begins. */
1747 void
1748 window_copy_cursor_previous_word(struct window_pane *wp, const char *separators)
1749 {
1750 struct window_copy_mode_data *data = wp->modedata;
1751 u_int px, py;
1752
1753 px = data->cx;
1754 py = screen_hsize(data->backing) + data->cy - data->oy;
1755
1756 /* Move back to the previous word character. */
1757 for (;;) {
1758 if (px > 0) {
1759 px--;
1760 if (!window_copy_in_set(wp, px, py, separators))
1761 break;
1762 } else {
1763 if (data->cy == 0 &&
1764 (screen_hsize(data->backing) == 0 ||
1765 data->oy >= screen_hsize(data->backing) - 1))
1766 goto out;
1767 window_copy_cursor_up(wp, 0);
1768
1769 py = screen_hsize(data->backing) + data->cy - data->oy;
1770 px = window_copy_find_length(wp, py);
1771 }
1772 }
1773
1774 /* Move back to the beginning of this word. */
1775 while (px > 0 && !window_copy_in_set(wp, px - 1, py, separators))
1776 px--;
1777
1778 out:
1779 window_copy_update_cursor(wp, px, data->cy);
1780 if (window_copy_update_selection(wp))
1781 window_copy_redraw_lines(wp, data->cy, 1);
1782 }
1783
1784 void
1785 window_copy_scroll_up(struct window_pane *wp, u_int ny)
1786 {
1787 struct window_copy_mode_data *data = wp->modedata;
1788 struct screen *s = &data->screen;
1789 struct screen_write_ctx ctx;
1790
1791 if (data->oy < ny)
1792 ny = data->oy;
1793 if (ny == 0)
1794 return;
1795 data->oy -= ny;
1796
1797 screen_write_start(&ctx, wp, NULL);
1798 screen_write_cursormove(&ctx, 0, 0);
1799 screen_write_deleteline(&ctx, ny);
1800 window_copy_write_lines(wp, &ctx, screen_size_y(s) - ny, ny);
1801 window_copy_write_line(wp, &ctx, 0);
1802 if (screen_size_y(s) > 1)
1803 window_copy_write_line(wp, &ctx, 1);
1804 if (screen_size_y(s) > 3)
1805 window_copy_write_line(wp, &ctx, screen_size_y(s) - 2);
1806 if (s->sel.flag && screen_size_y(s) > ny) {
1807 window_copy_update_selection(wp);
1808 window_copy_write_line(wp, &ctx, screen_size_y(s) - ny - 1);
1809 }
1810 screen_write_cursormove(&ctx, data->cx, data->cy);
1811 window_copy_update_selection(wp);
1812 screen_write_stop(&ctx);
1813 }
1814
1815 void
1816 window_copy_scroll_down(struct window_pane *wp, u_int ny)
1817 {
1818 struct window_copy_mode_data *data = wp->modedata;
1819 struct screen *s = &data->screen;
1820 struct screen_write_ctx ctx;
1821
1822 if (ny > screen_hsize(data->backing))
1823 return;
1824
1825 if (data->oy > screen_hsize(data->backing) - ny)
1826 ny = screen_hsize(data->backing) - data->oy;
1827 if (ny == 0)
1828 return;
1829 data->oy += ny;
1830
1831 screen_write_start(&ctx, wp, NULL);
1832 screen_write_cursormove(&ctx, 0, 0);
1833 screen_write_insertline(&ctx, ny);
1834 window_copy_write_lines(wp, &ctx, 0, ny);
1835 if (s->sel.flag && screen_size_y(s) > ny) {
1836 window_copy_update_selection(wp);
1837 window_copy_write_line(wp, &ctx, ny);
1838 } else if (ny == 1) /* nuke position */
1839 window_copy_write_line(wp, &ctx, 1);
1840 screen_write_cursormove(&ctx, data->cx, data->cy);
1841 window_copy_update_selection(wp);
1842 screen_write_stop(&ctx);
1843 }
1844
1845 void
1846 window_copy_rectangle_toggle(struct window_pane *wp)
1847 {
1848 struct window_copy_mode_data *data = wp->modedata;
1849 u_int px, py;
1850
1851 data->rectflag = !data->rectflag;
1852
1853 py = screen_hsize(data->backing) + data->cy - data->oy;
1854 px = window_copy_find_length(wp, py);
1855 if (data->cx > px)
1856 window_copy_update_cursor(wp, px, data->cy);
1857
1858 window_copy_update_selection(wp);
1859 window_copy_redraw_screen(wp);
1860 }