4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
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.
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.
19 #include <sys/types.h>
29 struct window_copy_mode_data
;
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
,
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
,
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
*,
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
,
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,
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
,
88 static void window_copy_start_selection(struct window_mode_entry
*);
89 static int window_copy_adjust_selection(struct window_mode_entry
*,
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,
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
*,
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
,
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
*,
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
*,
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
*,
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);
146 const struct window_mode window_copy_mode
= {
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
,
157 const struct window_mode window_view_mode
= {
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
,
170 WINDOW_COPY_SEARCHUP
,
171 WINDOW_COPY_SEARCHDOWN
,
172 WINDOW_COPY_JUMPFORWARD
,
173 WINDOW_COPY_JUMPBACKWARD
,
174 WINDOW_COPY_JUMPTOFORWARD
,
175 WINDOW_COPY_JUMPTOBACKWARD
,
179 WINDOW_COPY_REL_POS_ABOVE
,
180 WINDOW_COPY_REL_POS_ON_SCREEN
,
181 WINDOW_COPY_REL_POS_BELOW
,
184 enum window_copy_cmd_action
{
185 WINDOW_COPY_CMD_NOTHING
,
186 WINDOW_COPY_CMD_REDRAW
,
187 WINDOW_COPY_CMD_CANCEL
,
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
,
196 struct window_copy_cmd_state
{
197 struct window_mode_entry
*wme
;
199 struct mouse_event
*m
;
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).
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).
220 struct window_copy_mode_data
{
221 struct screen screen
;
223 struct screen
*backing
;
224 int backing_written
; /* backing display started */
225 struct screen
*writing
;
226 struct input_ctx
*ictx
;
228 int viewmode
; /* view mode entered */
230 u_int oy
; /* number of lines scrolled up */
232 u_int selx
; /* beginning of selection */
235 u_int endselx
; /* end of selection */
239 CURSORDRAG_NONE
, /* selection is independent of cursor */
240 CURSORDRAG_ENDSEL
, /* end is synchronized with cursor */
241 CURSORDRAG_SEL
, /* start is synchronized with cursor */
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 */
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 */
260 const char *separators
; /* word separators */
262 u_int dx
; /* drag start position */
265 u_int selrx
; /* selection reset positions */
273 u_int lastcx
; /* position in last line w/ content */
274 u_int lastsx
; /* size of last line w/ content */
276 u_int mx
; /* mark position */
293 int timeout
; /* search has timed out */
294 #define WINDOW_COPY_SEARCH_TIMEOUT 10000
295 #define WINDOW_COPY_SEARCH_ALL_TIMEOUT 200
298 struct utf8_data
*jumpchar
;
300 struct event dragtimer
;
301 #define WINDOW_COPY_DRAG_REPEAT_TIME 50000
305 window_copy_scroll_timer(__unused
int fd
, __unused
short events
, void *arg
)
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
314 evtimer_del(&data
->dragtimer
);
316 if (TAILQ_FIRST(&wp
->modes
) != wme
)
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);
328 static struct screen
*
329 window_copy_clone_screen(struct screen
*src
, struct screen
*hint
, u_int
*cx
,
333 const struct grid_line
*gl
;
337 dst
= xcalloc(1, sizeof *dst
);
339 sy
= screen_hsize(src
) + screen_size_y(src
);
341 while (sy
> screen_hsize(src
)) {
342 gl
= grid_peek_line(src
->grid
, sy
- 1);
343 if (gl
->cellused
!= 0)
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
));
354 * Ensure history is on for the backing grid so lines are not deleted
357 dst
->grid
->flags
|= GRID_HISTORY
;
358 grid_duplicate_lines(dst
->grid
, 0, src
->grid
, 0, sy
);
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) {
365 dst
->cy
= dst
->grid
->sy
- 1;
371 if (cx
!= NULL
&& cy
!= NULL
) {
373 *cy
= screen_hsize(dst
) + dst
->cy
;
374 reflow
= (screen_size_x(hint
) != screen_size_x(dst
));
379 grid_wrap_position(dst
->grid
, *cx
, *cy
, &wx
, &wy
);
380 screen_resize_cursor(dst
, screen_size_x(hint
), screen_size_y(hint
), 1,
383 grid_unwrap_position(dst
->grid
, cx
, cy
, wx
, wy
);
388 static struct window_copy_mode_data
*
389 window_copy_common_init(struct window_mode_entry
*wme
)
391 struct window_pane
*wp
= wme
->wp
;
392 struct window_copy_mode_data
*data
;
393 struct screen
*base
= &wp
->base
;
395 wme
->data
= data
= xcalloc(1, sizeof *data
);
397 data
->cursordrag
= CURSORDRAG_NONE
;
398 data
->lineflag
= LINE_SEL_NONE
;
399 data
->selflag
= SEL_CHAR
;
401 if (wp
->searchstr
!= NULL
) {
402 data
->searchtype
= WINDOW_COPY_SEARCHUP
;
403 data
->searchregex
= wp
->searchregex
;
404 data
->searchstr
= xstrdup(wp
->searchstr
);
406 data
->searchtype
= WINDOW_COPY_OFF
;
407 data
->searchregex
= 0;
408 data
->searchstr
= NULL
;
410 data
->searchx
= data
->searchy
= data
->searcho
= -1;
413 data
->jumptype
= WINDOW_COPY_OFF
;
414 data
->jumpchar
= NULL
;
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");
419 evtimer_set(&data
->dragtimer
, window_copy_scroll_timer
, wme
);
424 static struct screen
*
425 window_copy_init(struct window_mode_entry
*wme
,
426 __unused
struct cmd_find_state
*fs
, struct args
*args
)
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
;
434 data
= window_copy_common_init(wme
);
435 data
->backing
= window_copy_clone_screen(base
, &data
->screen
, &cx
, &cy
,
436 wme
->swp
!= wme
->wp
);
439 if (cy
< screen_hsize(data
->backing
)) {
441 data
->oy
= screen_hsize(data
->backing
) - cy
;
443 data
->cy
= cy
- screen_hsize(data
->backing
);
447 data
->scroll_exit
= args_has(args
, 'e');
448 data
->hide_position
= args_has(args
, 'H');
450 data
->screen
.cx
= data
->cx
;
451 data
->screen
.cy
= data
->cy
;
453 data
->my
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
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
);
462 return (&data
->screen
);
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
)
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
);
474 data
= window_copy_common_init(wme
);
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
);
483 data
->my
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
486 return (&data
->screen
);
490 window_copy_free(struct window_mode_entry
*wme
)
492 struct window_copy_mode_data
*data
= wme
->data
;
494 evtimer_del(&data
->dragtimer
);
496 free(data
->searchmark
);
497 free(data
->searchstr
);
498 free(data
->jumpchar
);
500 if (data
->writing
!= NULL
) {
501 screen_free(data
->writing
);
504 if (data
->ictx
!= NULL
)
505 input_free(data
->ictx
);
506 screen_free(data
->backing
);
509 screen_free(&data
->screen
);
514 window_copy_add(struct window_pane
*wp
, int parse
, const char *fmt
, ...)
519 window_copy_vadd(wp
, parse
, fmt
, ap
);
524 window_copy_init_ctx_cb(__unused
struct screen_write_ctx
*ctx
,
525 struct tty_ctx
*ttyctx
)
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
;
535 window_copy_vadd(struct window_pane
*wp
, int parse
, const char *fmt
, va_list ap
)
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
;
543 u_int old_hsize
, old_cy
;
544 u_int sx
= screen_size_x(backing
);
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
));
556 old_hsize
= screen_hsize(data
->backing
);
557 screen_write_start(&backing_ctx
, backing
);
558 if (data
->backing_written
) {
560 * On the second or later line, do a CRLF before writing
561 * (so it's on a new line).
563 screen_write_carriagereturn(&backing_ctx
);
564 screen_write_linefeed(&backing_ctx
, 0, 8);
566 data
->backing_written
= 1;
567 old_cy
= backing
->cy
;
569 screen_write_fast_copy(&backing_ctx
, writing
, 0, 0, sx
, 1);
571 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
572 screen_write_vnputs(&backing_ctx
, 0, &gc
, fmt
, ap
);
574 screen_write_stop(&backing_ctx
);
576 data
->oy
+= screen_hsize(data
->backing
) - old_hsize
;
578 screen_write_start_pane(&ctx
, wp
, &data
->screen
);
581 * If the history has changed, draw the top line.
582 * (If there's any history at all, it has changed.)
584 if (screen_hsize(data
->backing
))
585 window_copy_redraw_lines(wme
, 0, 1);
587 /* Write the new lines. */
588 window_copy_redraw_lines(wme
, old_cy
, backing
->cy
- old_cy
+ 1);
590 screen_write_stop(&ctx
);
594 window_copy_pageup(struct window_pane
*wp
, int half_page
)
596 window_copy_pageup1(TAILQ_FIRST(&wp
->modes
), half_page
);
600 window_copy_pageup1(struct window_mode_entry
*wme
, int half_page
)
602 struct window_copy_mode_data
*data
= wme
->data
;
603 struct screen
*s
= &data
->screen
;
604 u_int n
, ox
, oy
, px
, py
;
606 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
607 ox
= window_copy_find_length(wme
, oy
);
609 if (data
->cx
!= ox
) {
610 data
->lastcx
= data
->cx
;
613 data
->cx
= data
->lastcx
;
616 if (screen_size_y(s
) > 2) {
618 n
= screen_size_y(s
) / 2;
620 n
= screen_size_y(s
) - 2;
623 if (data
->oy
+ n
> screen_hsize(data
->backing
)) {
624 data
->oy
= screen_hsize(data
->backing
);
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
) ||
637 window_copy_cursor_end_of_line(wme
);
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
);
647 window_copy_pagedown(struct window_mode_entry
*wme
, int half_page
,
650 struct window_copy_mode_data
*data
= wme
->data
;
651 struct screen
*s
= &data
->screen
;
652 u_int n
, ox
, oy
, px
, py
;
654 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
655 ox
= window_copy_find_length(wme
, oy
);
657 if (data
->cx
!= ox
) {
658 data
->lastcx
= data
->cx
;
661 data
->cx
= data
->lastcx
;
664 if (screen_size_y(s
) > 2) {
666 n
= screen_size_y(s
) / 2;
668 n
= screen_size_y(s
) - 2;
673 if (data
->cy
+ (n
- data
->oy
) >= screen_size_y(data
->backing
))
674 data
->cy
= screen_size_y(data
->backing
) - 1;
676 data
->cy
+= n
- data
->oy
;
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
) ||
685 window_copy_cursor_end_of_line(wme
);
688 if (scroll_exit
&& data
->oy
== 0)
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
);
698 window_copy_previous_paragraph(struct window_mode_entry
*wme
)
700 struct window_copy_mode_data
*data
= wme
->data
;
703 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
705 while (oy
> 0 && window_copy_find_length(wme
, oy
) == 0)
708 while (oy
> 0 && window_copy_find_length(wme
, oy
) > 0)
711 window_copy_scroll_to(wme
, 0, oy
, 0);
715 window_copy_next_paragraph(struct window_mode_entry
*wme
)
717 struct window_copy_mode_data
*data
= wme
->data
;
718 struct screen
*s
= &data
->screen
;
721 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
722 maxy
= screen_hsize(data
->backing
) + screen_size_y(s
) - 1;
724 while (oy
< maxy
&& window_copy_find_length(wme
, oy
) == 0)
727 while (oy
< maxy
&& window_copy_find_length(wme
, oy
) > 0)
730 ox
= window_copy_find_length(wme
, oy
);
731 window_copy_scroll_to(wme
, ox
, oy
, 0);
735 window_copy_get_word(struct window_pane
*wp
, u_int x
, u_int y
)
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
;
741 return (format_grid_word(gd
, x
, gd
->hsize
+ y
));
745 window_copy_get_line(struct window_pane
*wp
, u_int y
)
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
;
751 return (format_grid_line(gd
, gd
->hsize
+ y
));
755 window_copy_cursor_word_cb(struct format_tree
*ft
)
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
;
761 return (window_copy_get_word(wp
, data
->cx
, data
->cy
));
765 window_copy_cursor_line_cb(struct format_tree
*ft
)
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
;
771 return (window_copy_get_line(wp
, data
->cy
));
775 window_copy_search_match_cb(struct format_tree
*ft
)
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
;
781 return (window_copy_match_at_cursor(data
));
785 window_copy_formats(struct window_mode_entry
*wme
, struct format_tree
*ft
)
787 struct window_copy_mode_data
*data
= wme
->data
;
789 format_add(ft
, "scroll_position", "%d", data
->oy
);
790 format_add(ft
, "rectangle_toggle", "%d", data
->rectflag
);
792 format_add(ft
, "copy_cursor_x", "%d", data
->cx
);
793 format_add(ft
, "copy_cursor_y", "%d", data
->cy
);
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
);
804 format_add(ft
, "selection_active", "%d", 0);
806 format_add(ft
, "search_present", "%d", data
->searchmark
!= NULL
);
807 format_add_cb(ft
, "search_match", window_copy_search_match_cb
);
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
);
814 window_copy_size_changed(struct window_mode_entry
*wme
)
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
);
821 window_copy_clear_selection(wme
);
822 window_copy_clear_marks(wme
);
824 screen_write_start(&ctx
, s
);
825 window_copy_write_lines(wme
, &ctx
, 0, screen_size_y(s
));
826 screen_write_stop(&ctx
);
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
;
836 window_copy_resize(struct window_mode_entry
*wme
, u_int sx
, u_int sy
)
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
;
844 screen_resize(s
, sx
, sy
, 0);
846 cy
= gd
->hsize
+ data
->cy
- data
->oy
;
847 reflow
= (gd
->sx
!= sx
);
849 grid_wrap_position(gd
, cx
, cy
, &wx
, &wy
);
850 screen_resize_cursor(data
->backing
, sx
, sy
, 1, 0, 0);
852 grid_unwrap_position(gd
, &cx
, &cy
, wx
, wy
);
855 if (cy
< gd
->hsize
) {
857 data
->oy
= gd
->hsize
- cy
;
859 data
->cy
= cy
- gd
->hsize
;
863 window_copy_size_changed(wme
);
864 window_copy_redraw_screen(wme
);
868 window_copy_key_table(struct window_mode_entry
*wme
)
870 struct window_pane
*wp
= wme
->wp
;
872 if (options_get_number(wp
->window
->options
, "mode-keys") == MODEKEY_VI
)
873 return ("copy-mode-vi");
874 return ("copy-mode");
878 window_copy_expand_search_string(struct window_copy_cmd_state
*cs
)
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);
885 if (ss
== NULL
|| *ss
== '\0')
888 if (args_has(cs
->args
, 'F')) {
889 expanded
= format_single(NULL
, ss
, NULL
, NULL
, NULL
, wme
->wp
);
890 if (*expanded
== '\0') {
894 free(data
->searchstr
);
895 data
->searchstr
= expanded
;
897 free(data
->searchstr
);
898 data
->searchstr
= xstrdup(ss
);
903 static enum window_copy_cmd_action
904 window_copy_cmd_append_selection(struct window_copy_cmd_state
*cs
)
906 struct window_mode_entry
*wme
= cs
->wme
;
907 struct session
*s
= cs
->s
;
910 window_copy_append_selection(wme
);
911 window_copy_clear_selection(wme
);
912 return (WINDOW_COPY_CMD_REDRAW
);
915 static enum window_copy_cmd_action
916 window_copy_cmd_append_selection_and_cancel(struct window_copy_cmd_state
*cs
)
918 struct window_mode_entry
*wme
= cs
->wme
;
919 struct session
*s
= cs
->s
;
922 window_copy_append_selection(wme
);
923 window_copy_clear_selection(wme
);
924 return (WINDOW_COPY_CMD_CANCEL
);
927 static enum window_copy_cmd_action
928 window_copy_cmd_back_to_indentation(struct window_copy_cmd_state
*cs
)
930 struct window_mode_entry
*wme
= cs
->wme
;
932 window_copy_cursor_back_to_indentation(wme
);
933 return (WINDOW_COPY_CMD_NOTHING
);
936 static enum window_copy_cmd_action
937 window_copy_cmd_begin_selection(struct window_copy_cmd_state
*cs
)
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
;
945 window_copy_start_drag(c
, m
);
946 return (WINDOW_COPY_CMD_NOTHING
);
949 data
->lineflag
= LINE_SEL_NONE
;
950 data
->selflag
= SEL_CHAR
;
951 window_copy_start_selection(wme
);
952 return (WINDOW_COPY_CMD_REDRAW
);
955 static enum window_copy_cmd_action
956 window_copy_cmd_stop_selection(struct window_copy_cmd_state
*cs
)
958 struct window_mode_entry
*wme
= cs
->wme
;
959 struct window_copy_mode_data
*data
= wme
->data
;
961 data
->cursordrag
= CURSORDRAG_NONE
;
962 data
->lineflag
= LINE_SEL_NONE
;
963 data
->selflag
= SEL_CHAR
;
964 return (WINDOW_COPY_CMD_NOTHING
);
967 static enum window_copy_cmd_action
968 window_copy_cmd_bottom_line(struct window_copy_cmd_state
*cs
)
970 struct window_mode_entry
*wme
= cs
->wme
;
971 struct window_copy_mode_data
*data
= wme
->data
;
974 data
->cy
= screen_size_y(&data
->screen
) - 1;
976 window_copy_update_selection(wme
, 1, 0);
977 return (WINDOW_COPY_CMD_REDRAW
);
980 static enum window_copy_cmd_action
981 window_copy_cmd_cancel(__unused
struct window_copy_cmd_state
*cs
)
983 return (WINDOW_COPY_CMD_CANCEL
);
986 static enum window_copy_cmd_action
987 window_copy_cmd_clear_selection(struct window_copy_cmd_state
*cs
)
989 struct window_mode_entry
*wme
= cs
->wme
;
991 window_copy_clear_selection(wme
);
992 return (WINDOW_COPY_CMD_REDRAW
);
995 static enum window_copy_cmd_action
996 window_copy_do_copy_end_of_line(struct window_copy_cmd_state
*cs
, int pipe
,
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);
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
);
1018 prefix
= format_single(NULL
, arg1
, c
, s
, wl
, wp
);
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
);
1032 window_copy_copy_pipe(wme
, s
, prefix
, command
);
1034 window_copy_copy_selection(wme
, prefix
);
1039 return (WINDOW_COPY_CMD_CANCEL
);
1042 window_copy_clear_selection(wme
);
1050 return (WINDOW_COPY_CMD_REDRAW
);
1053 static enum window_copy_cmd_action
1054 window_copy_cmd_copy_end_of_line(struct window_copy_cmd_state
*cs
)
1056 return (window_copy_do_copy_end_of_line(cs
, 0, 0));
1059 static enum window_copy_cmd_action
1060 window_copy_cmd_copy_end_of_line_and_cancel(struct window_copy_cmd_state
*cs
)
1062 return (window_copy_do_copy_end_of_line(cs
, 0, 1));
1065 static enum window_copy_cmd_action
1066 window_copy_cmd_copy_pipe_end_of_line(struct window_copy_cmd_state
*cs
)
1068 return (window_copy_do_copy_end_of_line(cs
, 1, 0));
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
)
1075 return (window_copy_do_copy_end_of_line(cs
, 1, 1));
1078 static enum window_copy_cmd_action
1079 window_copy_do_copy_line(struct window_copy_cmd_state
*cs
, int pipe
, int cancel
)
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);
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
);
1100 prefix
= format_single(NULL
, arg1
, c
, s
, wl
, wp
);
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
);
1116 window_copy_copy_pipe(wme
, s
, prefix
, command
);
1118 window_copy_copy_selection(wme
, prefix
);
1123 return (WINDOW_COPY_CMD_CANCEL
);
1126 window_copy_clear_selection(wme
);
1134 return (WINDOW_COPY_CMD_REDRAW
);
1137 static enum window_copy_cmd_action
1138 window_copy_cmd_copy_line(struct window_copy_cmd_state
*cs
)
1140 return (window_copy_do_copy_line(cs
, 0, 0));
1143 static enum window_copy_cmd_action
1144 window_copy_cmd_copy_line_and_cancel(struct window_copy_cmd_state
*cs
)
1146 return (window_copy_do_copy_line(cs
, 0, 1));
1149 static enum window_copy_cmd_action
1150 window_copy_cmd_copy_pipe_line(struct window_copy_cmd_state
*cs
)
1152 return (window_copy_do_copy_line(cs
, 1, 0));
1155 static enum window_copy_cmd_action
1156 window_copy_cmd_copy_pipe_line_and_cancel(struct window_copy_cmd_state
*cs
)
1158 return (window_copy_do_copy_line(cs
, 1, 1));
1161 static enum window_copy_cmd_action
1162 window_copy_cmd_copy_selection_no_clear(struct window_copy_cmd_state
*cs
)
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);
1173 prefix
= format_single(NULL
, arg1
, c
, s
, wl
, wp
);
1176 window_copy_copy_selection(wme
, prefix
);
1179 return (WINDOW_COPY_CMD_NOTHING
);
1182 static enum window_copy_cmd_action
1183 window_copy_cmd_copy_selection(struct window_copy_cmd_state
*cs
)
1185 struct window_mode_entry
*wme
= cs
->wme
;
1187 window_copy_cmd_copy_selection_no_clear(cs
);
1188 window_copy_clear_selection(wme
);
1189 return (WINDOW_COPY_CMD_REDRAW
);
1192 static enum window_copy_cmd_action
1193 window_copy_cmd_copy_selection_and_cancel(struct window_copy_cmd_state
*cs
)
1195 struct window_mode_entry
*wme
= cs
->wme
;
1197 window_copy_cmd_copy_selection_no_clear(cs
);
1198 window_copy_clear_selection(wme
);
1199 return (WINDOW_COPY_CMD_CANCEL
);
1202 static enum window_copy_cmd_action
1203 window_copy_cmd_cursor_down(struct window_copy_cmd_state
*cs
)
1205 struct window_mode_entry
*wme
= cs
->wme
;
1206 u_int np
= wme
->prefix
;
1208 for (; np
!= 0; np
--)
1209 window_copy_cursor_down(wme
, 0);
1210 return (WINDOW_COPY_CMD_NOTHING
);
1213 static enum window_copy_cmd_action
1214 window_copy_cmd_cursor_down_and_cancel(struct window_copy_cmd_state
*cs
)
1216 struct window_mode_entry
*wme
= cs
->wme
;
1217 struct window_copy_mode_data
*data
= wme
->data
;
1218 u_int np
= wme
->prefix
, 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
);
1228 static enum window_copy_cmd_action
1229 window_copy_cmd_cursor_left(struct window_copy_cmd_state
*cs
)
1231 struct window_mode_entry
*wme
= cs
->wme
;
1232 u_int np
= wme
->prefix
;
1234 for (; np
!= 0; np
--)
1235 window_copy_cursor_left(wme
);
1236 return (WINDOW_COPY_CMD_NOTHING
);
1239 static enum window_copy_cmd_action
1240 window_copy_cmd_cursor_right(struct window_copy_cmd_state
*cs
)
1242 struct window_mode_entry
*wme
= cs
->wme
;
1243 struct window_copy_mode_data
*data
= wme
->data
;
1244 u_int np
= wme
->prefix
;
1246 for (; np
!= 0; np
--) {
1247 window_copy_cursor_right(wme
, data
->screen
.sel
!= NULL
&&
1250 return (WINDOW_COPY_CMD_NOTHING
);
1253 static enum window_copy_cmd_action
1254 window_copy_cmd_scroll_middle(struct window_copy_cmd_state
*cs
)
1256 struct window_mode_entry
*wme
= cs
->wme
;
1257 struct window_copy_mode_data
*data
= wme
->data
;
1258 u_int mid_value
, oy
, delta
;
1259 int scroll_up
; /* >0 up, <0 down */
1261 mid_value
= (screen_size_y(&data
->screen
) - 1) / 2;
1262 scroll_up
= data
->cy
- mid_value
;
1263 delta
= abs(scroll_up
);
1264 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1266 log_debug ("XXX %u %u %u %d %u", mid_value
, oy
, delta
, scroll_up
, data
->oy
);
1267 if (scroll_up
> 0 && data
->oy
>= delta
) {
1268 window_copy_scroll_up(wme
, delta
);
1270 } else if (scroll_up
< 0 && oy
>= delta
) {
1271 window_copy_scroll_down(wme
, delta
);
1275 window_copy_update_selection(wme
, 0, 0);
1276 return (WINDOW_COPY_CMD_REDRAW
);
1279 static enum window_copy_cmd_action
1280 window_copy_cmd_cursor_up(struct window_copy_cmd_state
*cs
)
1282 struct window_mode_entry
*wme
= cs
->wme
;
1283 u_int np
= wme
->prefix
;
1285 for (; np
!= 0; np
--)
1286 window_copy_cursor_up(wme
, 0);
1287 return (WINDOW_COPY_CMD_NOTHING
);
1290 static enum window_copy_cmd_action
1291 window_copy_cmd_end_of_line(struct window_copy_cmd_state
*cs
)
1293 struct window_mode_entry
*wme
= cs
->wme
;
1295 window_copy_cursor_end_of_line(wme
);
1296 return (WINDOW_COPY_CMD_NOTHING
);
1299 static enum window_copy_cmd_action
1300 window_copy_cmd_halfpage_down(struct window_copy_cmd_state
*cs
)
1302 struct window_mode_entry
*wme
= cs
->wme
;
1303 struct window_copy_mode_data
*data
= wme
->data
;
1304 u_int np
= wme
->prefix
;
1306 for (; np
!= 0; np
--) {
1307 if (window_copy_pagedown(wme
, 1, data
->scroll_exit
))
1308 return (WINDOW_COPY_CMD_CANCEL
);
1310 return (WINDOW_COPY_CMD_NOTHING
);
1313 static enum window_copy_cmd_action
1314 window_copy_cmd_halfpage_down_and_cancel(struct window_copy_cmd_state
*cs
)
1317 struct window_mode_entry
*wme
= cs
->wme
;
1318 u_int np
= wme
->prefix
;
1320 for (; np
!= 0; np
--) {
1321 if (window_copy_pagedown(wme
, 1, 1))
1322 return (WINDOW_COPY_CMD_CANCEL
);
1324 return (WINDOW_COPY_CMD_NOTHING
);
1327 static enum window_copy_cmd_action
1328 window_copy_cmd_halfpage_up(struct window_copy_cmd_state
*cs
)
1330 struct window_mode_entry
*wme
= cs
->wme
;
1331 u_int np
= wme
->prefix
;
1333 for (; np
!= 0; np
--)
1334 window_copy_pageup1(wme
, 1);
1335 return (WINDOW_COPY_CMD_NOTHING
);
1338 static enum window_copy_cmd_action
1339 window_copy_cmd_toggle_position(struct window_copy_cmd_state
*cs
)
1341 struct window_mode_entry
*wme
= cs
->wme
;
1342 struct window_copy_mode_data
*data
= wme
->data
;
1344 data
->hide_position
= !data
->hide_position
;
1345 return (WINDOW_COPY_CMD_REDRAW
);
1348 static enum window_copy_cmd_action
1349 window_copy_cmd_history_bottom(struct window_copy_cmd_state
*cs
)
1351 struct window_mode_entry
*wme
= cs
->wme
;
1352 struct window_copy_mode_data
*data
= wme
->data
;
1353 struct screen
*s
= data
->backing
;
1356 oy
= screen_hsize(s
) + data
->cy
- data
->oy
;
1357 if (data
->lineflag
== LINE_SEL_RIGHT_LEFT
&& oy
== data
->endsely
)
1358 window_copy_other_end(wme
);
1360 data
->cy
= screen_size_y(&data
->screen
) - 1;
1361 data
->cx
= window_copy_find_length(wme
, screen_hsize(s
) + data
->cy
);
1364 if (data
->searchmark
!= NULL
&& !data
->timeout
)
1365 window_copy_search_marks(wme
, NULL
, data
->searchregex
, 1);
1366 window_copy_update_selection(wme
, 1, 0);
1367 return (WINDOW_COPY_CMD_REDRAW
);
1370 static enum window_copy_cmd_action
1371 window_copy_cmd_history_top(struct window_copy_cmd_state
*cs
)
1373 struct window_mode_entry
*wme
= cs
->wme
;
1374 struct window_copy_mode_data
*data
= wme
->data
;
1377 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1378 if (data
->lineflag
== LINE_SEL_LEFT_RIGHT
&& oy
== data
->sely
)
1379 window_copy_other_end(wme
);
1383 data
->oy
= screen_hsize(data
->backing
);
1385 if (data
->searchmark
!= NULL
&& !data
->timeout
)
1386 window_copy_search_marks(wme
, NULL
, data
->searchregex
, 1);
1387 window_copy_update_selection(wme
, 1, 0);
1388 return (WINDOW_COPY_CMD_REDRAW
);
1391 static enum window_copy_cmd_action
1392 window_copy_cmd_jump_again(struct window_copy_cmd_state
*cs
)
1394 struct window_mode_entry
*wme
= cs
->wme
;
1395 struct window_copy_mode_data
*data
= wme
->data
;
1396 u_int np
= wme
->prefix
;
1398 switch (data
->jumptype
) {
1399 case WINDOW_COPY_JUMPFORWARD
:
1400 for (; np
!= 0; np
--)
1401 window_copy_cursor_jump(wme
);
1403 case WINDOW_COPY_JUMPBACKWARD
:
1404 for (; np
!= 0; np
--)
1405 window_copy_cursor_jump_back(wme
);
1407 case WINDOW_COPY_JUMPTOFORWARD
:
1408 for (; np
!= 0; np
--)
1409 window_copy_cursor_jump_to(wme
);
1411 case WINDOW_COPY_JUMPTOBACKWARD
:
1412 for (; np
!= 0; np
--)
1413 window_copy_cursor_jump_to_back(wme
);
1416 return (WINDOW_COPY_CMD_NOTHING
);
1419 static enum window_copy_cmd_action
1420 window_copy_cmd_jump_reverse(struct window_copy_cmd_state
*cs
)
1422 struct window_mode_entry
*wme
= cs
->wme
;
1423 struct window_copy_mode_data
*data
= wme
->data
;
1424 u_int np
= wme
->prefix
;
1426 switch (data
->jumptype
) {
1427 case WINDOW_COPY_JUMPFORWARD
:
1428 for (; np
!= 0; np
--)
1429 window_copy_cursor_jump_back(wme
);
1431 case WINDOW_COPY_JUMPBACKWARD
:
1432 for (; np
!= 0; np
--)
1433 window_copy_cursor_jump(wme
);
1435 case WINDOW_COPY_JUMPTOFORWARD
:
1436 for (; np
!= 0; np
--)
1437 window_copy_cursor_jump_to_back(wme
);
1439 case WINDOW_COPY_JUMPTOBACKWARD
:
1440 for (; np
!= 0; np
--)
1441 window_copy_cursor_jump_to(wme
);
1444 return (WINDOW_COPY_CMD_NOTHING
);
1447 static enum window_copy_cmd_action
1448 window_copy_cmd_middle_line(struct window_copy_cmd_state
*cs
)
1450 struct window_mode_entry
*wme
= cs
->wme
;
1451 struct window_copy_mode_data
*data
= wme
->data
;
1454 data
->cy
= (screen_size_y(&data
->screen
) - 1) / 2;
1456 window_copy_update_selection(wme
, 1, 0);
1457 return (WINDOW_COPY_CMD_REDRAW
);
1460 static enum window_copy_cmd_action
1461 window_copy_cmd_previous_matching_bracket(struct window_copy_cmd_state
*cs
)
1463 struct window_mode_entry
*wme
= cs
->wme
;
1464 u_int np
= wme
->prefix
;
1465 struct window_copy_mode_data
*data
= wme
->data
;
1466 struct screen
*s
= data
->backing
;
1467 char open
[] = "{[(", close
[] = "}])";
1468 char tried
, found
, start
, *cp
;
1469 u_int px
, py
, xx
, n
;
1470 struct grid_cell gc
;
1473 for (; np
!= 0; np
--) {
1474 /* Get cursor position and line length. */
1476 py
= screen_hsize(s
) + data
->cy
- data
->oy
;
1477 xx
= window_copy_find_length(wme
, py
);
1482 * Get the current character. If not on a bracket, try the
1483 * previous. If still not, then behave like previous-word.
1487 grid_get_cell(s
->grid
, px
, py
, &gc
);
1488 if (gc
.data
.size
!= 1 || (gc
.flags
& GRID_FLAG_PADDING
))
1491 found
= *gc
.data
.data
;
1492 cp
= strchr(close
, found
);
1495 if (data
->modekeys
== MODEKEY_EMACS
) {
1496 if (!tried
&& px
> 0) {
1501 window_copy_cursor_previous_word(wme
, close
, 1);
1505 start
= open
[cp
- close
];
1507 /* Walk backward until the matching bracket is reached. */
1518 xx
= window_copy_find_length(wme
, py
);
1519 } while (xx
== 0 && py
> 0);
1520 if (xx
== 0 && py
== 0) {
1528 grid_get_cell(s
->grid
, px
, py
, &gc
);
1529 if (gc
.data
.size
== 1 &&
1530 (~gc
.flags
& GRID_FLAG_PADDING
)) {
1531 if (*gc
.data
.data
== found
)
1533 else if (*gc
.data
.data
== start
)
1538 /* Move the cursor to the found location if any. */
1540 window_copy_scroll_to(wme
, px
, py
, 0);
1543 return (WINDOW_COPY_CMD_NOTHING
);
1546 static enum window_copy_cmd_action
1547 window_copy_cmd_next_matching_bracket(struct window_copy_cmd_state
*cs
)
1549 struct window_mode_entry
*wme
= cs
->wme
;
1550 u_int np
= wme
->prefix
;
1551 struct window_copy_mode_data
*data
= wme
->data
;
1552 struct screen
*s
= data
->backing
;
1553 char open
[] = "{[(", close
[] = "}])";
1554 char tried
, found
, end
, *cp
;
1555 u_int px
, py
, xx
, yy
, sx
, sy
, n
;
1556 struct grid_cell gc
;
1558 struct grid_line
*gl
;
1560 for (; np
!= 0; np
--) {
1561 /* Get cursor position and line length. */
1563 py
= screen_hsize(s
) + data
->cy
- data
->oy
;
1564 xx
= window_copy_find_length(wme
, py
);
1565 yy
= screen_hsize(s
) + screen_size_y(s
) - 1;
1570 * Get the current character. If not on a bracket, try the
1571 * next. If still not, then behave like next-word.
1575 grid_get_cell(s
->grid
, px
, py
, &gc
);
1576 if (gc
.data
.size
!= 1 || (gc
.flags
& GRID_FLAG_PADDING
))
1579 found
= *gc
.data
.data
;
1582 * In vi mode, attempt to move to previous bracket if a
1583 * closing bracket is found first. If this fails,
1584 * return to the original cursor position.
1586 cp
= strchr(close
, found
);
1587 if (cp
!= NULL
&& data
->modekeys
== MODEKEY_VI
) {
1589 sy
= screen_hsize(s
) + data
->cy
- data
->oy
;
1591 window_copy_scroll_to(wme
, px
, py
, 0);
1592 window_copy_cmd_previous_matching_bracket(cs
);
1595 py
= screen_hsize(s
) + data
->cy
- data
->oy
;
1596 grid_get_cell(s
->grid
, px
, py
, &gc
);
1597 if (gc
.data
.size
== 1 &&
1598 (~gc
.flags
& GRID_FLAG_PADDING
) &&
1599 strchr(close
, *gc
.data
.data
) != NULL
)
1600 window_copy_scroll_to(wme
, sx
, sy
, 0);
1604 cp
= strchr(open
, found
);
1607 if (data
->modekeys
== MODEKEY_EMACS
) {
1608 if (!tried
&& px
<= xx
) {
1613 window_copy_cursor_next_word_end(wme
, open
, 0);
1616 /* For vi, continue searching for bracket until EOL. */
1620 gl
= grid_get_line(s
->grid
, py
);
1621 if (~gl
->flags
& GRID_LINE_WRAPPED
)
1623 if (gl
->cellsize
> s
->grid
->sx
)
1627 xx
= window_copy_find_length(wme
, py
);
1632 end
= close
[cp
- open
];
1634 /* Walk forward until the matching bracket is reached. */
1645 xx
= window_copy_find_length(wme
, py
);
1649 grid_get_cell(s
->grid
, px
, py
, &gc
);
1650 if (gc
.data
.size
== 1 &&
1651 (~gc
.flags
& GRID_FLAG_PADDING
)) {
1652 if (*gc
.data
.data
== found
)
1654 else if (*gc
.data
.data
== end
)
1659 /* Move the cursor to the found location if any. */
1661 window_copy_scroll_to(wme
, px
, py
, 0);
1664 return (WINDOW_COPY_CMD_NOTHING
);
1667 static enum window_copy_cmd_action
1668 window_copy_cmd_next_paragraph(struct window_copy_cmd_state
*cs
)
1670 struct window_mode_entry
*wme
= cs
->wme
;
1671 u_int np
= wme
->prefix
;
1673 for (; np
!= 0; np
--)
1674 window_copy_next_paragraph(wme
);
1675 return (WINDOW_COPY_CMD_NOTHING
);
1678 static enum window_copy_cmd_action
1679 window_copy_cmd_next_space(struct window_copy_cmd_state
*cs
)
1681 struct window_mode_entry
*wme
= cs
->wme
;
1682 u_int np
= wme
->prefix
;
1684 for (; np
!= 0; np
--)
1685 window_copy_cursor_next_word(wme
, "");
1686 return (WINDOW_COPY_CMD_NOTHING
);
1689 static enum window_copy_cmd_action
1690 window_copy_cmd_next_space_end(struct window_copy_cmd_state
*cs
)
1692 struct window_mode_entry
*wme
= cs
->wme
;
1693 u_int np
= wme
->prefix
;
1695 for (; np
!= 0; np
--)
1696 window_copy_cursor_next_word_end(wme
, "", 0);
1697 return (WINDOW_COPY_CMD_NOTHING
);
1700 static enum window_copy_cmd_action
1701 window_copy_cmd_next_word(struct window_copy_cmd_state
*cs
)
1703 struct window_mode_entry
*wme
= cs
->wme
;
1704 u_int np
= wme
->prefix
;
1705 const char *separators
;
1707 separators
= options_get_string(cs
->s
->options
, "word-separators");
1709 for (; np
!= 0; np
--)
1710 window_copy_cursor_next_word(wme
, separators
);
1711 return (WINDOW_COPY_CMD_NOTHING
);
1714 static enum window_copy_cmd_action
1715 window_copy_cmd_next_word_end(struct window_copy_cmd_state
*cs
)
1717 struct window_mode_entry
*wme
= cs
->wme
;
1718 u_int np
= wme
->prefix
;
1719 const char *separators
;
1721 separators
= options_get_string(cs
->s
->options
, "word-separators");
1723 for (; np
!= 0; np
--)
1724 window_copy_cursor_next_word_end(wme
, separators
, 0);
1725 return (WINDOW_COPY_CMD_NOTHING
);
1728 static enum window_copy_cmd_action
1729 window_copy_cmd_other_end(struct window_copy_cmd_state
*cs
)
1731 struct window_mode_entry
*wme
= cs
->wme
;
1732 u_int np
= wme
->prefix
;
1733 struct window_copy_mode_data
*data
= wme
->data
;
1735 data
->selflag
= SEL_CHAR
;
1737 window_copy_other_end(wme
);
1738 return (WINDOW_COPY_CMD_NOTHING
);
1741 static enum window_copy_cmd_action
1742 window_copy_cmd_page_down(struct window_copy_cmd_state
*cs
)
1744 struct window_mode_entry
*wme
= cs
->wme
;
1745 struct window_copy_mode_data
*data
= wme
->data
;
1746 u_int np
= wme
->prefix
;
1748 for (; np
!= 0; np
--) {
1749 if (window_copy_pagedown(wme
, 0, data
->scroll_exit
))
1750 return (WINDOW_COPY_CMD_CANCEL
);
1752 return (WINDOW_COPY_CMD_NOTHING
);
1755 static enum window_copy_cmd_action
1756 window_copy_cmd_page_down_and_cancel(struct window_copy_cmd_state
*cs
)
1758 struct window_mode_entry
*wme
= cs
->wme
;
1759 u_int np
= wme
->prefix
;
1761 for (; np
!= 0; np
--) {
1762 if (window_copy_pagedown(wme
, 0, 1))
1763 return (WINDOW_COPY_CMD_CANCEL
);
1765 return (WINDOW_COPY_CMD_NOTHING
);
1768 static enum window_copy_cmd_action
1769 window_copy_cmd_page_up(struct window_copy_cmd_state
*cs
)
1771 struct window_mode_entry
*wme
= cs
->wme
;
1772 u_int np
= wme
->prefix
;
1774 for (; np
!= 0; np
--)
1775 window_copy_pageup1(wme
, 0);
1776 return (WINDOW_COPY_CMD_NOTHING
);
1779 static enum window_copy_cmd_action
1780 window_copy_cmd_previous_paragraph(struct window_copy_cmd_state
*cs
)
1782 struct window_mode_entry
*wme
= cs
->wme
;
1783 u_int np
= wme
->prefix
;
1785 for (; np
!= 0; np
--)
1786 window_copy_previous_paragraph(wme
);
1787 return (WINDOW_COPY_CMD_NOTHING
);
1790 static enum window_copy_cmd_action
1791 window_copy_cmd_previous_space(struct window_copy_cmd_state
*cs
)
1793 struct window_mode_entry
*wme
= cs
->wme
;
1794 u_int np
= wme
->prefix
;
1796 for (; np
!= 0; np
--)
1797 window_copy_cursor_previous_word(wme
, "", 1);
1798 return (WINDOW_COPY_CMD_NOTHING
);
1801 static enum window_copy_cmd_action
1802 window_copy_cmd_previous_word(struct window_copy_cmd_state
*cs
)
1804 struct window_mode_entry
*wme
= cs
->wme
;
1805 u_int np
= wme
->prefix
;
1806 const char *separators
;
1808 separators
= options_get_string(cs
->s
->options
, "word-separators");
1810 for (; np
!= 0; np
--)
1811 window_copy_cursor_previous_word(wme
, separators
, 1);
1812 return (WINDOW_COPY_CMD_NOTHING
);
1815 static enum window_copy_cmd_action
1816 window_copy_cmd_rectangle_on(struct window_copy_cmd_state
*cs
)
1818 struct window_mode_entry
*wme
= cs
->wme
;
1819 struct window_copy_mode_data
*data
= wme
->data
;
1821 data
->lineflag
= LINE_SEL_NONE
;
1822 window_copy_rectangle_set(wme
, 1);
1824 return (WINDOW_COPY_CMD_NOTHING
);
1827 static enum window_copy_cmd_action
1828 window_copy_cmd_rectangle_off(struct window_copy_cmd_state
*cs
)
1830 struct window_mode_entry
*wme
= cs
->wme
;
1831 struct window_copy_mode_data
*data
= wme
->data
;
1833 data
->lineflag
= LINE_SEL_NONE
;
1834 window_copy_rectangle_set(wme
, 0);
1836 return (WINDOW_COPY_CMD_NOTHING
);
1839 static enum window_copy_cmd_action
1840 window_copy_cmd_rectangle_toggle(struct window_copy_cmd_state
*cs
)
1842 struct window_mode_entry
*wme
= cs
->wme
;
1843 struct window_copy_mode_data
*data
= wme
->data
;
1845 data
->lineflag
= LINE_SEL_NONE
;
1846 window_copy_rectangle_set(wme
, !data
->rectflag
);
1848 return (WINDOW_COPY_CMD_NOTHING
);
1851 static enum window_copy_cmd_action
1852 window_copy_cmd_scroll_down(struct window_copy_cmd_state
*cs
)
1854 struct window_mode_entry
*wme
= cs
->wme
;
1855 struct window_copy_mode_data
*data
= wme
->data
;
1856 u_int np
= wme
->prefix
;
1858 for (; np
!= 0; np
--)
1859 window_copy_cursor_down(wme
, 1);
1860 if (data
->scroll_exit
&& data
->oy
== 0)
1861 return (WINDOW_COPY_CMD_CANCEL
);
1862 return (WINDOW_COPY_CMD_NOTHING
);
1865 static enum window_copy_cmd_action
1866 window_copy_cmd_scroll_down_and_cancel(struct window_copy_cmd_state
*cs
)
1868 struct window_mode_entry
*wme
= cs
->wme
;
1869 struct window_copy_mode_data
*data
= wme
->data
;
1870 u_int np
= wme
->prefix
;
1872 for (; np
!= 0; np
--)
1873 window_copy_cursor_down(wme
, 1);
1875 return (WINDOW_COPY_CMD_CANCEL
);
1876 return (WINDOW_COPY_CMD_NOTHING
);
1879 static enum window_copy_cmd_action
1880 window_copy_cmd_scroll_up(struct window_copy_cmd_state
*cs
)
1882 struct window_mode_entry
*wme
= cs
->wme
;
1883 u_int np
= wme
->prefix
;
1885 for (; np
!= 0; np
--)
1886 window_copy_cursor_up(wme
, 1);
1887 return (WINDOW_COPY_CMD_NOTHING
);
1890 static enum window_copy_cmd_action
1891 window_copy_cmd_search_again(struct window_copy_cmd_state
*cs
)
1893 struct window_mode_entry
*wme
= cs
->wme
;
1894 struct window_copy_mode_data
*data
= wme
->data
;
1895 u_int np
= wme
->prefix
;
1897 if (data
->searchtype
== WINDOW_COPY_SEARCHUP
) {
1898 for (; np
!= 0; np
--)
1899 window_copy_search_up(wme
, data
->searchregex
);
1900 } else if (data
->searchtype
== WINDOW_COPY_SEARCHDOWN
) {
1901 for (; np
!= 0; np
--)
1902 window_copy_search_down(wme
, data
->searchregex
);
1904 return (WINDOW_COPY_CMD_NOTHING
);
1907 static enum window_copy_cmd_action
1908 window_copy_cmd_search_reverse(struct window_copy_cmd_state
*cs
)
1910 struct window_mode_entry
*wme
= cs
->wme
;
1911 struct window_copy_mode_data
*data
= wme
->data
;
1912 u_int np
= wme
->prefix
;
1914 if (data
->searchtype
== WINDOW_COPY_SEARCHUP
) {
1915 for (; np
!= 0; np
--)
1916 window_copy_search_down(wme
, data
->searchregex
);
1917 } else if (data
->searchtype
== WINDOW_COPY_SEARCHDOWN
) {
1918 for (; np
!= 0; np
--)
1919 window_copy_search_up(wme
, data
->searchregex
);
1921 return (WINDOW_COPY_CMD_NOTHING
);
1924 static enum window_copy_cmd_action
1925 window_copy_cmd_select_line(struct window_copy_cmd_state
*cs
)
1927 struct window_mode_entry
*wme
= cs
->wme
;
1928 struct window_copy_mode_data
*data
= wme
->data
;
1929 u_int np
= wme
->prefix
;
1931 data
->lineflag
= LINE_SEL_LEFT_RIGHT
;
1933 data
->selflag
= SEL_LINE
;
1934 data
->dx
= data
->cx
;
1935 data
->dy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1937 window_copy_cursor_start_of_line(wme
);
1938 data
->selrx
= data
->cx
;
1939 data
->selry
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1940 data
->endselry
= data
->selry
;
1941 window_copy_start_selection(wme
);
1942 window_copy_cursor_end_of_line(wme
);
1943 data
->endselry
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1944 data
->endselrx
= window_copy_find_length(wme
, data
->endselry
);
1945 for (; np
> 1; np
--) {
1946 window_copy_cursor_down(wme
, 0);
1947 window_copy_cursor_end_of_line(wme
);
1950 return (WINDOW_COPY_CMD_REDRAW
);
1953 static enum window_copy_cmd_action
1954 window_copy_cmd_select_word(struct window_copy_cmd_state
*cs
)
1956 struct window_mode_entry
*wme
= cs
->wme
;
1957 struct options
*session_options
= cs
->s
->options
;
1958 struct window_copy_mode_data
*data
= wme
->data
;
1959 u_int px
, py
, nextx
, nexty
;
1961 data
->lineflag
= LINE_SEL_LEFT_RIGHT
;
1963 data
->selflag
= SEL_WORD
;
1964 data
->dx
= data
->cx
;
1965 data
->dy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1967 data
->separators
= options_get_string(session_options
,
1969 window_copy_cursor_previous_word(wme
, data
->separators
, 0);
1971 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1974 window_copy_start_selection(wme
);
1976 /* Handle single character words. */
1979 if (grid_get_line(data
->backing
->grid
, nexty
)->flags
&
1980 GRID_LINE_WRAPPED
&& nextx
> screen_size_x(data
->backing
) - 1) {
1984 if (px
>= window_copy_find_length(wme
, py
) ||
1985 !window_copy_in_set(wme
, nextx
, nexty
, WHITESPACE
))
1986 window_copy_cursor_next_word_end(wme
, data
->separators
, 1);
1988 window_copy_update_cursor(wme
, px
, data
->cy
);
1989 if (window_copy_update_selection(wme
, 1, 1))
1990 window_copy_redraw_lines(wme
, data
->cy
, 1);
1992 data
->endselrx
= data
->cx
;
1993 data
->endselry
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1994 if (data
->dy
> data
->endselry
) {
1995 data
->dy
= data
->endselry
;
1996 data
->dx
= data
->endselrx
;
1997 } else if (data
->dx
> data
->endselrx
)
1998 data
->dx
= data
->endselrx
;
2000 return (WINDOW_COPY_CMD_REDRAW
);
2003 static enum window_copy_cmd_action
2004 window_copy_cmd_set_mark(struct window_copy_cmd_state
*cs
)
2006 struct window_copy_mode_data
*data
= cs
->wme
->data
;
2008 data
->mx
= data
->cx
;
2009 data
->my
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
2011 return (WINDOW_COPY_CMD_REDRAW
);
2014 static enum window_copy_cmd_action
2015 window_copy_cmd_start_of_line(struct window_copy_cmd_state
*cs
)
2017 struct window_mode_entry
*wme
= cs
->wme
;
2019 window_copy_cursor_start_of_line(wme
);
2020 return (WINDOW_COPY_CMD_NOTHING
);
2023 static enum window_copy_cmd_action
2024 window_copy_cmd_top_line(struct window_copy_cmd_state
*cs
)
2026 struct window_mode_entry
*wme
= cs
->wme
;
2027 struct window_copy_mode_data
*data
= wme
->data
;
2032 window_copy_update_selection(wme
, 1, 0);
2033 return (WINDOW_COPY_CMD_REDRAW
);
2036 static enum window_copy_cmd_action
2037 window_copy_cmd_copy_pipe_no_clear(struct window_copy_cmd_state
*cs
)
2039 struct window_mode_entry
*wme
= cs
->wme
;
2040 struct client
*c
= cs
->c
;
2041 struct session
*s
= cs
->s
;
2042 struct winlink
*wl
= cs
->wl
;
2043 struct window_pane
*wp
= wme
->wp
;
2044 char *command
= NULL
, *prefix
= NULL
;
2045 const char *arg1
= args_string(cs
->args
, 1);
2046 const char *arg2
= args_string(cs
->args
, 2);
2049 prefix
= format_single(NULL
, arg2
, c
, s
, wl
, wp
);
2051 if (s
!= NULL
&& arg1
!= NULL
&& *arg1
!= '\0')
2052 command
= format_single(NULL
, arg1
, c
, s
, wl
, wp
);
2053 window_copy_copy_pipe(wme
, s
, prefix
, command
);
2057 return (WINDOW_COPY_CMD_NOTHING
);
2060 static enum window_copy_cmd_action
2061 window_copy_cmd_copy_pipe(struct window_copy_cmd_state
*cs
)
2063 struct window_mode_entry
*wme
= cs
->wme
;
2065 window_copy_cmd_copy_pipe_no_clear(cs
);
2066 window_copy_clear_selection(wme
);
2067 return (WINDOW_COPY_CMD_REDRAW
);
2070 static enum window_copy_cmd_action
2071 window_copy_cmd_copy_pipe_and_cancel(struct window_copy_cmd_state
*cs
)
2073 struct window_mode_entry
*wme
= cs
->wme
;
2075 window_copy_cmd_copy_pipe_no_clear(cs
);
2076 window_copy_clear_selection(wme
);
2077 return (WINDOW_COPY_CMD_CANCEL
);
2080 static enum window_copy_cmd_action
2081 window_copy_cmd_pipe_no_clear(struct window_copy_cmd_state
*cs
)
2083 struct window_mode_entry
*wme
= cs
->wme
;
2084 struct client
*c
= cs
->c
;
2085 struct session
*s
= cs
->s
;
2086 struct winlink
*wl
= cs
->wl
;
2087 struct window_pane
*wp
= wme
->wp
;
2088 char *command
= NULL
;
2089 const char *arg1
= args_string(cs
->args
, 1);
2091 if (s
!= NULL
&& arg1
!= NULL
&& *arg1
!= '\0')
2092 command
= format_single(NULL
, arg1
, c
, s
, wl
, wp
);
2093 window_copy_pipe(wme
, s
, command
);
2096 return (WINDOW_COPY_CMD_NOTHING
);
2099 static enum window_copy_cmd_action
2100 window_copy_cmd_pipe(struct window_copy_cmd_state
*cs
)
2102 struct window_mode_entry
*wme
= cs
->wme
;
2104 window_copy_cmd_pipe_no_clear(cs
);
2105 window_copy_clear_selection(wme
);
2106 return (WINDOW_COPY_CMD_REDRAW
);
2109 static enum window_copy_cmd_action
2110 window_copy_cmd_pipe_and_cancel(struct window_copy_cmd_state
*cs
)
2112 struct window_mode_entry
*wme
= cs
->wme
;
2114 window_copy_cmd_pipe_no_clear(cs
);
2115 window_copy_clear_selection(wme
);
2116 return (WINDOW_COPY_CMD_CANCEL
);
2119 static enum window_copy_cmd_action
2120 window_copy_cmd_goto_line(struct window_copy_cmd_state
*cs
)
2122 struct window_mode_entry
*wme
= cs
->wme
;
2123 const char *arg1
= args_string(cs
->args
, 1);
2126 window_copy_goto_line(wme
, arg1
);
2127 return (WINDOW_COPY_CMD_NOTHING
);
2130 static enum window_copy_cmd_action
2131 window_copy_cmd_jump_backward(struct window_copy_cmd_state
*cs
)
2133 struct window_mode_entry
*wme
= cs
->wme
;
2134 struct window_copy_mode_data
*data
= wme
->data
;
2135 u_int np
= wme
->prefix
;
2136 const char *arg1
= args_string(cs
->args
, 1);
2138 if (*arg1
!= '\0') {
2139 data
->jumptype
= WINDOW_COPY_JUMPBACKWARD
;
2140 free(data
->jumpchar
);
2141 data
->jumpchar
= utf8_fromcstr(arg1
);
2142 for (; np
!= 0; np
--)
2143 window_copy_cursor_jump_back(wme
);
2145 return (WINDOW_COPY_CMD_NOTHING
);
2148 static enum window_copy_cmd_action
2149 window_copy_cmd_jump_forward(struct window_copy_cmd_state
*cs
)
2151 struct window_mode_entry
*wme
= cs
->wme
;
2152 struct window_copy_mode_data
*data
= wme
->data
;
2153 u_int np
= wme
->prefix
;
2154 const char *arg1
= args_string(cs
->args
, 1);
2156 if (*arg1
!= '\0') {
2157 data
->jumptype
= WINDOW_COPY_JUMPFORWARD
;
2158 free(data
->jumpchar
);
2159 data
->jumpchar
= utf8_fromcstr(arg1
);
2160 for (; np
!= 0; np
--)
2161 window_copy_cursor_jump(wme
);
2163 return (WINDOW_COPY_CMD_NOTHING
);
2166 static enum window_copy_cmd_action
2167 window_copy_cmd_jump_to_backward(struct window_copy_cmd_state
*cs
)
2169 struct window_mode_entry
*wme
= cs
->wme
;
2170 struct window_copy_mode_data
*data
= wme
->data
;
2171 u_int np
= wme
->prefix
;
2172 const char *arg1
= args_string(cs
->args
, 1);
2174 if (*arg1
!= '\0') {
2175 data
->jumptype
= WINDOW_COPY_JUMPTOBACKWARD
;
2176 free(data
->jumpchar
);
2177 data
->jumpchar
= utf8_fromcstr(arg1
);
2178 for (; np
!= 0; np
--)
2179 window_copy_cursor_jump_to_back(wme
);
2181 return (WINDOW_COPY_CMD_NOTHING
);
2184 static enum window_copy_cmd_action
2185 window_copy_cmd_jump_to_forward(struct window_copy_cmd_state
*cs
)
2187 struct window_mode_entry
*wme
= cs
->wme
;
2188 struct window_copy_mode_data
*data
= wme
->data
;
2189 u_int np
= wme
->prefix
;
2190 const char *arg1
= args_string(cs
->args
, 1);
2192 if (*arg1
!= '\0') {
2193 data
->jumptype
= WINDOW_COPY_JUMPTOFORWARD
;
2194 free(data
->jumpchar
);
2195 data
->jumpchar
= utf8_fromcstr(arg1
);
2196 for (; np
!= 0; np
--)
2197 window_copy_cursor_jump_to(wme
);
2199 return (WINDOW_COPY_CMD_NOTHING
);
2202 static enum window_copy_cmd_action
2203 window_copy_cmd_jump_to_mark(struct window_copy_cmd_state
*cs
)
2205 struct window_mode_entry
*wme
= cs
->wme
;
2207 window_copy_jump_to_mark(wme
);
2208 return (WINDOW_COPY_CMD_NOTHING
);
2211 static enum window_copy_cmd_action
2212 window_copy_cmd_search_backward(struct window_copy_cmd_state
*cs
)
2214 struct window_mode_entry
*wme
= cs
->wme
;
2215 struct window_copy_mode_data
*data
= wme
->data
;
2216 u_int np
= wme
->prefix
;
2218 if (!window_copy_expand_search_string(cs
))
2219 return (WINDOW_COPY_CMD_NOTHING
);
2221 if (data
->searchstr
!= NULL
) {
2222 data
->searchtype
= WINDOW_COPY_SEARCHUP
;
2223 data
->searchregex
= 1;
2225 for (; np
!= 0; np
--)
2226 window_copy_search_up(wme
, 1);
2228 return (WINDOW_COPY_CMD_NOTHING
);
2231 static enum window_copy_cmd_action
2232 window_copy_cmd_search_backward_text(struct window_copy_cmd_state
*cs
)
2234 struct window_mode_entry
*wme
= cs
->wme
;
2235 struct window_copy_mode_data
*data
= wme
->data
;
2236 u_int np
= wme
->prefix
;
2238 if (!window_copy_expand_search_string(cs
))
2239 return (WINDOW_COPY_CMD_NOTHING
);
2241 if (data
->searchstr
!= NULL
) {
2242 data
->searchtype
= WINDOW_COPY_SEARCHUP
;
2243 data
->searchregex
= 0;
2245 for (; np
!= 0; np
--)
2246 window_copy_search_up(wme
, 0);
2248 return (WINDOW_COPY_CMD_NOTHING
);
2251 static enum window_copy_cmd_action
2252 window_copy_cmd_search_forward(struct window_copy_cmd_state
*cs
)
2254 struct window_mode_entry
*wme
= cs
->wme
;
2255 struct window_copy_mode_data
*data
= wme
->data
;
2256 u_int np
= wme
->prefix
;
2258 if (!window_copy_expand_search_string(cs
))
2259 return (WINDOW_COPY_CMD_NOTHING
);
2261 if (data
->searchstr
!= NULL
) {
2262 data
->searchtype
= WINDOW_COPY_SEARCHDOWN
;
2263 data
->searchregex
= 1;
2265 for (; np
!= 0; np
--)
2266 window_copy_search_down(wme
, 1);
2268 return (WINDOW_COPY_CMD_NOTHING
);
2271 static enum window_copy_cmd_action
2272 window_copy_cmd_search_forward_text(struct window_copy_cmd_state
*cs
)
2274 struct window_mode_entry
*wme
= cs
->wme
;
2275 struct window_copy_mode_data
*data
= wme
->data
;
2276 u_int np
= wme
->prefix
;
2278 if (!window_copy_expand_search_string(cs
))
2279 return (WINDOW_COPY_CMD_NOTHING
);
2281 if (data
->searchstr
!= NULL
) {
2282 data
->searchtype
= WINDOW_COPY_SEARCHDOWN
;
2283 data
->searchregex
= 0;
2285 for (; np
!= 0; np
--)
2286 window_copy_search_down(wme
, 0);
2288 return (WINDOW_COPY_CMD_NOTHING
);
2291 static enum window_copy_cmd_action
2292 window_copy_cmd_search_backward_incremental(struct window_copy_cmd_state
*cs
)
2294 struct window_mode_entry
*wme
= cs
->wme
;
2295 struct window_copy_mode_data
*data
= wme
->data
;
2296 const char *arg1
= args_string(cs
->args
, 1);
2297 const char *ss
= data
->searchstr
;
2299 enum window_copy_cmd_action action
= WINDOW_COPY_CMD_NOTHING
;
2303 log_debug("%s: %s", __func__
, arg1
);
2306 if (data
->searchx
== -1 || data
->searchy
== -1) {
2307 data
->searchx
= data
->cx
;
2308 data
->searchy
= data
->cy
;
2309 data
->searcho
= data
->oy
;
2310 } else if (ss
!= NULL
&& strcmp(arg1
, ss
) != 0) {
2311 data
->cx
= data
->searchx
;
2312 data
->cy
= data
->searchy
;
2313 data
->oy
= data
->searcho
;
2314 action
= WINDOW_COPY_CMD_REDRAW
;
2316 if (*arg1
== '\0') {
2317 window_copy_clear_marks(wme
);
2318 return (WINDOW_COPY_CMD_REDRAW
);
2323 data
->searchtype
= WINDOW_COPY_SEARCHUP
;
2324 data
->searchregex
= 0;
2325 free(data
->searchstr
);
2326 data
->searchstr
= xstrdup(arg1
);
2327 if (!window_copy_search_up(wme
, 0)) {
2328 window_copy_clear_marks(wme
);
2329 return (WINDOW_COPY_CMD_REDRAW
);
2333 data
->searchtype
= WINDOW_COPY_SEARCHDOWN
;
2334 data
->searchregex
= 0;
2335 free(data
->searchstr
);
2336 data
->searchstr
= xstrdup(arg1
);
2337 if (!window_copy_search_down(wme
, 0)) {
2338 window_copy_clear_marks(wme
);
2339 return (WINDOW_COPY_CMD_REDRAW
);
2346 static enum window_copy_cmd_action
2347 window_copy_cmd_search_forward_incremental(struct window_copy_cmd_state
*cs
)
2349 struct window_mode_entry
*wme
= cs
->wme
;
2350 struct window_copy_mode_data
*data
= wme
->data
;
2351 const char *arg1
= args_string(cs
->args
, 1);
2352 const char *ss
= data
->searchstr
;
2354 enum window_copy_cmd_action action
= WINDOW_COPY_CMD_NOTHING
;
2358 log_debug("%s: %s", __func__
, arg1
);
2361 if (data
->searchx
== -1 || data
->searchy
== -1) {
2362 data
->searchx
= data
->cx
;
2363 data
->searchy
= data
->cy
;
2364 data
->searcho
= data
->oy
;
2365 } else if (ss
!= NULL
&& strcmp(arg1
, ss
) != 0) {
2366 data
->cx
= data
->searchx
;
2367 data
->cy
= data
->searchy
;
2368 data
->oy
= data
->searcho
;
2369 action
= WINDOW_COPY_CMD_REDRAW
;
2371 if (*arg1
== '\0') {
2372 window_copy_clear_marks(wme
);
2373 return (WINDOW_COPY_CMD_REDRAW
);
2378 data
->searchtype
= WINDOW_COPY_SEARCHDOWN
;
2379 data
->searchregex
= 0;
2380 free(data
->searchstr
);
2381 data
->searchstr
= xstrdup(arg1
);
2382 if (!window_copy_search_down(wme
, 0)) {
2383 window_copy_clear_marks(wme
);
2384 return (WINDOW_COPY_CMD_REDRAW
);
2388 data
->searchtype
= WINDOW_COPY_SEARCHUP
;
2389 data
->searchregex
= 0;
2390 free(data
->searchstr
);
2391 data
->searchstr
= xstrdup(arg1
);
2392 if (!window_copy_search_up(wme
, 0)) {
2393 window_copy_clear_marks(wme
);
2394 return (WINDOW_COPY_CMD_REDRAW
);
2400 static enum window_copy_cmd_action
2401 window_copy_cmd_refresh_from_pane(struct window_copy_cmd_state
*cs
)
2403 struct window_mode_entry
*wme
= cs
->wme
;
2404 struct window_pane
*wp
= wme
->swp
;
2405 struct window_copy_mode_data
*data
= wme
->data
;
2408 return (WINDOW_COPY_CMD_NOTHING
);
2410 screen_free(data
->backing
);
2411 free(data
->backing
);
2412 data
->backing
= window_copy_clone_screen(&wp
->base
, &data
->screen
, NULL
, NULL
, wme
->swp
!= wme
->wp
);
2414 window_copy_size_changed(wme
);
2415 return (WINDOW_COPY_CMD_REDRAW
);
2418 static const struct {
2419 const char *command
;
2422 enum window_copy_cmd_clear clear
;
2423 enum window_copy_cmd_action (*f
)(struct window_copy_cmd_state
*);
2424 } window_copy_cmd_table
[] = {
2425 { .command
= "append-selection",
2428 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2429 .f
= window_copy_cmd_append_selection
2431 { .command
= "append-selection-and-cancel",
2434 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2435 .f
= window_copy_cmd_append_selection_and_cancel
2437 { .command
= "back-to-indentation",
2440 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2441 .f
= window_copy_cmd_back_to_indentation
2443 { .command
= "begin-selection",
2446 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2447 .f
= window_copy_cmd_begin_selection
2449 { .command
= "bottom-line",
2452 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2453 .f
= window_copy_cmd_bottom_line
2455 { .command
= "cancel",
2458 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2459 .f
= window_copy_cmd_cancel
2461 { .command
= "clear-selection",
2464 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2465 .f
= window_copy_cmd_clear_selection
2467 { .command
= "copy-end-of-line",
2470 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2471 .f
= window_copy_cmd_copy_end_of_line
2473 { .command
= "copy-end-of-line-and-cancel",
2476 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2477 .f
= window_copy_cmd_copy_end_of_line_and_cancel
2479 { .command
= "copy-pipe-end-of-line",
2482 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2483 .f
= window_copy_cmd_copy_pipe_end_of_line
2485 { .command
= "copy-pipe-end-of-line-and-cancel",
2488 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2489 .f
= window_copy_cmd_copy_pipe_end_of_line_and_cancel
2491 { .command
= "copy-line",
2494 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2495 .f
= window_copy_cmd_copy_line
2497 { .command
= "copy-line-and-cancel",
2500 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2501 .f
= window_copy_cmd_copy_line_and_cancel
2503 { .command
= "copy-pipe-line",
2506 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2507 .f
= window_copy_cmd_copy_pipe_line
2509 { .command
= "copy-pipe-line-and-cancel",
2512 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2513 .f
= window_copy_cmd_copy_pipe_line_and_cancel
2515 { .command
= "copy-pipe-no-clear",
2518 .clear
= WINDOW_COPY_CMD_CLEAR_NEVER
,
2519 .f
= window_copy_cmd_copy_pipe_no_clear
2521 { .command
= "copy-pipe",
2524 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2525 .f
= window_copy_cmd_copy_pipe
2527 { .command
= "copy-pipe-and-cancel",
2530 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2531 .f
= window_copy_cmd_copy_pipe_and_cancel
2533 { .command
= "copy-selection-no-clear",
2536 .clear
= WINDOW_COPY_CMD_CLEAR_NEVER
,
2537 .f
= window_copy_cmd_copy_selection_no_clear
2539 { .command
= "copy-selection",
2542 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2543 .f
= window_copy_cmd_copy_selection
2545 { .command
= "copy-selection-and-cancel",
2548 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2549 .f
= window_copy_cmd_copy_selection_and_cancel
2551 { .command
= "cursor-down",
2554 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2555 .f
= window_copy_cmd_cursor_down
2557 { .command
= "cursor-down-and-cancel",
2560 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2561 .f
= window_copy_cmd_cursor_down_and_cancel
2563 { .command
= "cursor-left",
2566 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2567 .f
= window_copy_cmd_cursor_left
2569 { .command
= "cursor-right",
2572 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2573 .f
= window_copy_cmd_cursor_right
2575 { .command
= "cursor-up",
2578 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2579 .f
= window_copy_cmd_cursor_up
2581 { .command
= "end-of-line",
2584 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2585 .f
= window_copy_cmd_end_of_line
2587 { .command
= "goto-line",
2590 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2591 .f
= window_copy_cmd_goto_line
2593 { .command
= "halfpage-down",
2596 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2597 .f
= window_copy_cmd_halfpage_down
2599 { .command
= "halfpage-down-and-cancel",
2602 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2603 .f
= window_copy_cmd_halfpage_down_and_cancel
2605 { .command
= "halfpage-up",
2608 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2609 .f
= window_copy_cmd_halfpage_up
2611 { .command
= "history-bottom",
2614 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2615 .f
= window_copy_cmd_history_bottom
2617 { .command
= "history-top",
2620 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2621 .f
= window_copy_cmd_history_top
2623 { .command
= "jump-again",
2626 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2627 .f
= window_copy_cmd_jump_again
2629 { .command
= "jump-backward",
2632 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2633 .f
= window_copy_cmd_jump_backward
2635 { .command
= "jump-forward",
2638 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2639 .f
= window_copy_cmd_jump_forward
2641 { .command
= "jump-reverse",
2644 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2645 .f
= window_copy_cmd_jump_reverse
2647 { .command
= "jump-to-backward",
2650 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2651 .f
= window_copy_cmd_jump_to_backward
2653 { .command
= "jump-to-forward",
2656 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2657 .f
= window_copy_cmd_jump_to_forward
2659 { .command
= "jump-to-mark",
2662 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2663 .f
= window_copy_cmd_jump_to_mark
2665 { .command
= "middle-line",
2668 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2669 .f
= window_copy_cmd_middle_line
2671 { .command
= "next-matching-bracket",
2674 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2675 .f
= window_copy_cmd_next_matching_bracket
2677 { .command
= "next-paragraph",
2680 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2681 .f
= window_copy_cmd_next_paragraph
2683 { .command
= "next-space",
2686 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2687 .f
= window_copy_cmd_next_space
2689 { .command
= "next-space-end",
2692 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2693 .f
= window_copy_cmd_next_space_end
2695 { .command
= "next-word",
2698 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2699 .f
= window_copy_cmd_next_word
2701 { .command
= "next-word-end",
2704 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2705 .f
= window_copy_cmd_next_word_end
2707 { .command
= "other-end",
2710 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2711 .f
= window_copy_cmd_other_end
2713 { .command
= "page-down",
2716 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2717 .f
= window_copy_cmd_page_down
2719 { .command
= "page-down-and-cancel",
2722 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2723 .f
= window_copy_cmd_page_down_and_cancel
2725 { .command
= "page-up",
2728 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2729 .f
= window_copy_cmd_page_up
2731 { .command
= "pipe-no-clear",
2734 .clear
= WINDOW_COPY_CMD_CLEAR_NEVER
,
2735 .f
= window_copy_cmd_pipe_no_clear
2737 { .command
= "pipe",
2740 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2741 .f
= window_copy_cmd_pipe
2743 { .command
= "pipe-and-cancel",
2746 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2747 .f
= window_copy_cmd_pipe_and_cancel
2749 { .command
= "previous-matching-bracket",
2752 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2753 .f
= window_copy_cmd_previous_matching_bracket
2755 { .command
= "previous-paragraph",
2758 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2759 .f
= window_copy_cmd_previous_paragraph
2761 { .command
= "previous-space",
2764 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2765 .f
= window_copy_cmd_previous_space
2767 { .command
= "previous-word",
2770 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2771 .f
= window_copy_cmd_previous_word
2773 { .command
= "rectangle-on",
2776 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2777 .f
= window_copy_cmd_rectangle_on
2779 { .command
= "rectangle-off",
2782 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2783 .f
= window_copy_cmd_rectangle_off
2785 { .command
= "rectangle-toggle",
2788 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2789 .f
= window_copy_cmd_rectangle_toggle
2791 { .command
= "refresh-from-pane",
2794 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2795 .f
= window_copy_cmd_refresh_from_pane
2797 { .command
= "scroll-down",
2800 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2801 .f
= window_copy_cmd_scroll_down
2803 { .command
= "scroll-down-and-cancel",
2806 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2807 .f
= window_copy_cmd_scroll_down_and_cancel
2809 { .command
= "scroll-middle",
2812 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2813 .f
= window_copy_cmd_scroll_middle
2815 { .command
= "scroll-up",
2818 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2819 .f
= window_copy_cmd_scroll_up
2821 { .command
= "search-again",
2824 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2825 .f
= window_copy_cmd_search_again
2827 { .command
= "search-backward",
2830 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2831 .f
= window_copy_cmd_search_backward
2833 { .command
= "search-backward-text",
2836 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2837 .f
= window_copy_cmd_search_backward_text
2839 { .command
= "search-backward-incremental",
2842 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2843 .f
= window_copy_cmd_search_backward_incremental
2845 { .command
= "search-forward",
2848 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2849 .f
= window_copy_cmd_search_forward
2851 { .command
= "search-forward-text",
2854 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2855 .f
= window_copy_cmd_search_forward_text
2857 { .command
= "search-forward-incremental",
2860 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2861 .f
= window_copy_cmd_search_forward_incremental
2863 { .command
= "search-reverse",
2866 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2867 .f
= window_copy_cmd_search_reverse
2869 { .command
= "select-line",
2872 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2873 .f
= window_copy_cmd_select_line
2875 { .command
= "select-word",
2878 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2879 .f
= window_copy_cmd_select_word
2881 { .command
= "set-mark",
2884 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2885 .f
= window_copy_cmd_set_mark
2887 { .command
= "start-of-line",
2890 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2891 .f
= window_copy_cmd_start_of_line
2893 { .command
= "stop-selection",
2896 .clear
= WINDOW_COPY_CMD_CLEAR_ALWAYS
,
2897 .f
= window_copy_cmd_stop_selection
2899 { .command
= "toggle-position",
2902 .clear
= WINDOW_COPY_CMD_CLEAR_NEVER
,
2903 .f
= window_copy_cmd_toggle_position
2905 { .command
= "top-line",
2908 .clear
= WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
,
2909 .f
= window_copy_cmd_top_line
2914 window_copy_command(struct window_mode_entry
*wme
, struct client
*c
,
2915 struct session
*s
, struct winlink
*wl
, struct args
*args
,
2916 struct mouse_event
*m
)
2918 struct window_copy_mode_data
*data
= wme
->data
;
2919 struct window_copy_cmd_state cs
;
2920 enum window_copy_cmd_action action
;
2921 enum window_copy_cmd_clear clear
= WINDOW_COPY_CMD_CLEAR_NEVER
;
2922 const char *command
;
2923 u_int i
, count
= args_count(args
);
2928 command
= args_string(args
, 0);
2930 if (m
!= NULL
&& m
->valid
&& !MOUSE_WHEEL(m
->b
))
2931 window_copy_move_mouse(m
);
2941 action
= WINDOW_COPY_CMD_NOTHING
;
2942 for (i
= 0; i
< nitems(window_copy_cmd_table
); i
++) {
2943 if (strcmp(window_copy_cmd_table
[i
].command
, command
) == 0) {
2944 if (count
- 1 < window_copy_cmd_table
[i
].minargs
||
2945 count
- 1 > window_copy_cmd_table
[i
].maxargs
)
2947 clear
= window_copy_cmd_table
[i
].clear
;
2948 action
= window_copy_cmd_table
[i
].f(&cs
);
2953 if (strncmp(command
, "search-", 7) != 0 && data
->searchmark
!= NULL
) {
2954 keys
= options_get_number(wme
->wp
->window
->options
, "mode-keys");
2955 if (clear
== WINDOW_COPY_CMD_CLEAR_EMACS_ONLY
&&
2957 clear
= WINDOW_COPY_CMD_CLEAR_NEVER
;
2958 if (clear
!= WINDOW_COPY_CMD_CLEAR_NEVER
) {
2959 window_copy_clear_marks(wme
);
2960 data
->searchx
= data
->searchy
= -1;
2962 if (action
== WINDOW_COPY_CMD_NOTHING
)
2963 action
= WINDOW_COPY_CMD_REDRAW
;
2967 if (action
== WINDOW_COPY_CMD_CANCEL
)
2968 window_pane_reset_mode(wme
->wp
);
2969 else if (action
== WINDOW_COPY_CMD_REDRAW
)
2970 window_copy_redraw_screen(wme
);
2974 window_copy_scroll_to(struct window_mode_entry
*wme
, u_int px
, u_int py
,
2977 struct window_copy_mode_data
*data
= wme
->data
;
2978 struct grid
*gd
= data
->backing
->grid
;
2983 if (py
>= gd
->hsize
- data
->oy
&& py
< gd
->hsize
- data
->oy
+ gd
->sy
)
2984 data
->cy
= py
- (gd
->hsize
- data
->oy
);
2990 } else if (py
> gd
->hsize
+ gd
->sy
- gap
) {
2992 data
->cy
= py
- gd
->hsize
;
2994 offset
= py
+ gap
- gd
->sy
;
2995 data
->cy
= py
- offset
;
2997 data
->oy
= gd
->hsize
- offset
;
3000 if (!no_redraw
&& data
->searchmark
!= NULL
&& !data
->timeout
)
3001 window_copy_search_marks(wme
, NULL
, data
->searchregex
, 1);
3002 window_copy_update_selection(wme
, 1, 0);
3004 window_copy_redraw_screen(wme
);
3008 window_copy_search_compare(struct grid
*gd
, u_int px
, u_int py
,
3009 struct grid
*sgd
, u_int spx
, int cis
)
3011 struct grid_cell gc
, sgc
;
3012 const struct utf8_data
*ud
, *sud
;
3014 grid_get_cell(gd
, px
, py
, &gc
);
3016 grid_get_cell(sgd
, spx
, 0, &sgc
);
3019 if (ud
->size
!= sud
->size
|| ud
->width
!= sud
->width
)
3022 if (cis
&& ud
->size
== 1)
3023 return (tolower(ud
->data
[0]) == sud
->data
[0]);
3025 return (memcmp(ud
->data
, sud
->data
, ud
->size
) == 0);
3029 window_copy_search_lr(struct grid
*gd
, struct grid
*sgd
, u_int
*ppx
, u_int py
,
3030 u_int first
, u_int last
, int cis
)
3032 u_int ax
, bx
, px
, pywrap
, endline
;
3034 struct grid_line
*gl
;
3036 endline
= gd
->hsize
+ gd
->sy
- 1;
3037 for (ax
= first
; ax
< last
; ax
++) {
3038 for (bx
= 0; bx
< sgd
->sx
; bx
++) {
3042 while (px
>= gd
->sx
&& pywrap
< endline
) {
3043 gl
= grid_get_line(gd
, pywrap
);
3044 if (~gl
->flags
& GRID_LINE_WRAPPED
)
3049 /* We have run off the end of the grid. */
3052 matched
= window_copy_search_compare(gd
, px
, pywrap
,
3057 if (bx
== sgd
->sx
) {
3066 window_copy_search_rl(struct grid
*gd
,
3067 struct grid
*sgd
, u_int
*ppx
, u_int py
, u_int first
, u_int last
, int cis
)
3069 u_int ax
, bx
, px
, pywrap
, endline
;
3071 struct grid_line
*gl
;
3073 endline
= gd
->hsize
+ gd
->sy
- 1;
3074 for (ax
= last
; ax
> first
; ax
--) {
3075 for (bx
= 0; bx
< sgd
->sx
; bx
++) {
3079 while (px
>= gd
->sx
&& pywrap
< endline
) {
3080 gl
= grid_get_line(gd
, pywrap
);
3081 if (~gl
->flags
& GRID_LINE_WRAPPED
)
3086 /* We have run off the end of the grid. */
3089 matched
= window_copy_search_compare(gd
, px
, pywrap
,
3094 if (bx
== sgd
->sx
) {
3103 window_copy_search_lr_regex(struct grid
*gd
, u_int
*ppx
, u_int
*psx
, u_int py
,
3104 u_int first
, u_int last
, regex_t
*reg
)
3107 u_int endline
, foundx
, foundy
, len
, pywrap
, size
= 1;
3109 regmatch_t regmatch
;
3110 struct grid_line
*gl
;
3113 * This can happen during search if the last match was the last
3114 * character on a line.
3119 /* Set flags for regex search. */
3121 eflags
|= REG_NOTBOL
;
3123 /* Need to look at the entire string. */
3124 buf
= xmalloc(size
);
3126 buf
= window_copy_stringify(gd
, py
, first
, gd
->sx
, buf
, &size
);
3127 len
= gd
->sx
- first
;
3128 endline
= gd
->hsize
+ gd
->sy
- 1;
3130 while (buf
!= NULL
&& pywrap
<= endline
) {
3131 gl
= grid_get_line(gd
, pywrap
);
3132 if (~gl
->flags
& GRID_LINE_WRAPPED
)
3135 buf
= window_copy_stringify(gd
, pywrap
, 0, gd
->sx
, buf
, &size
);
3139 if (regexec(reg
, buf
, 1, ®match
, eflags
) == 0 &&
3140 regmatch
.rm_so
!= regmatch
.rm_eo
) {
3143 window_copy_cstrtocellpos(gd
, len
, &foundx
, &foundy
,
3144 buf
+ regmatch
.rm_so
);
3145 if (foundy
== py
&& foundx
< last
) {
3147 len
-= foundx
- first
;
3148 window_copy_cstrtocellpos(gd
, len
, &foundx
, &foundy
,
3149 buf
+ regmatch
.rm_eo
);
3151 while (foundy
> py
) {
3168 window_copy_search_rl_regex(struct grid
*gd
, u_int
*ppx
, u_int
*psx
, u_int py
,
3169 u_int first
, u_int last
, regex_t
*reg
)
3172 u_int endline
, len
, pywrap
, size
= 1;
3174 struct grid_line
*gl
;
3176 /* Set flags for regex search. */
3178 eflags
|= REG_NOTBOL
;
3180 /* Need to look at the entire string. */
3181 buf
= xmalloc(size
);
3183 buf
= window_copy_stringify(gd
, py
, first
, gd
->sx
, buf
, &size
);
3184 len
= gd
->sx
- first
;
3185 endline
= gd
->hsize
+ gd
->sy
- 1;
3187 while (buf
!= NULL
&& (pywrap
<= endline
)) {
3188 gl
= grid_get_line(gd
, pywrap
);
3189 if (~gl
->flags
& GRID_LINE_WRAPPED
)
3192 buf
= window_copy_stringify(gd
, pywrap
, 0, gd
->sx
, buf
, &size
);
3196 if (window_copy_last_regex(gd
, py
, first
, last
, len
, ppx
, psx
, buf
,
3210 window_copy_cellstring(const struct grid_line
*gl
, u_int px
, size_t *size
,
3213 static struct utf8_data ud
;
3214 struct grid_cell_entry
*gce
;
3217 if (px
>= gl
->cellsize
) {
3223 gce
= &gl
->celldata
[px
];
3224 if (gce
->flags
& GRID_FLAG_PADDING
) {
3229 if (~gce
->flags
& GRID_FLAG_EXTENDED
) {
3232 return (&gce
->data
.data
);
3235 utf8_to_data(gl
->extddata
[gce
->offset
].data
, &ud
);
3244 copy
= xmalloc(ud
.size
);
3245 memcpy(copy
, ud
.data
, ud
.size
);
3249 /* Find last match in given range. */
3251 window_copy_last_regex(struct grid
*gd
, u_int py
, u_int first
, u_int last
,
3252 u_int len
, u_int
*ppx
, u_int
*psx
, const char *buf
, const regex_t
*preg
,
3255 u_int foundx
, foundy
, oldx
, px
= 0, savepx
, savesx
= 0;
3256 regmatch_t regmatch
;
3261 while (regexec(preg
, buf
+ px
, 1, ®match
, eflags
) == 0) {
3262 if (regmatch
.rm_so
== regmatch
.rm_eo
)
3264 window_copy_cstrtocellpos(gd
, len
, &foundx
, &foundy
,
3265 buf
+ px
+ regmatch
.rm_so
);
3266 if (foundy
> py
|| foundx
>= last
)
3268 len
-= foundx
- oldx
;
3270 window_copy_cstrtocellpos(gd
, len
, &foundx
, &foundy
,
3271 buf
+ px
+ regmatch
.rm_eo
);
3272 if (foundy
> py
|| foundx
>= last
) {
3275 while (foundy
> py
) {
3282 savesx
= foundx
- savepx
;
3286 px
+= regmatch
.rm_eo
;
3300 /* Stringify line and append to input buffer. Caller frees. */
3302 window_copy_stringify(struct grid
*gd
, u_int py
, u_int first
, u_int last
,
3303 char *buf
, u_int
*size
)
3305 u_int ax
, bx
, newsize
= *size
;
3306 const struct grid_line
*gl
;
3308 size_t bufsize
= 1024, dlen
;
3311 while (bufsize
< newsize
)
3313 buf
= xrealloc(buf
, bufsize
);
3315 gl
= grid_peek_line(gd
, py
);
3317 for (ax
= first
; ax
< last
; ax
++) {
3318 d
= window_copy_cellstring(gl
, ax
, &dlen
, &allocated
);
3320 while (bufsize
< newsize
) {
3322 buf
= xrealloc(buf
, bufsize
);
3327 memcpy(buf
+ bx
, d
, dlen
);
3333 buf
[newsize
- 1] = '\0';
3339 /* Map start of C string containing UTF-8 data to grid cell position. */
3341 window_copy_cstrtocellpos(struct grid
*gd
, u_int ncells
, u_int
*ppx
, u_int
*ppy
,
3344 u_int cell
, ccell
, px
, pywrap
, pos
, len
;
3346 const struct grid_line
*gl
;
3355 /* Populate the array of cell data. */
3356 cells
= xreallocarray(NULL
, ncells
, sizeof cells
[0]);
3360 gl
= grid_peek_line(gd
, pywrap
);
3361 while (cell
< ncells
) {
3362 cells
[cell
].d
= window_copy_cellstring(gl
, px
,
3363 &cells
[cell
].dlen
, &cells
[cell
].allocated
);
3369 gl
= grid_peek_line(gd
, pywrap
);
3373 /* Locate starting cell. */
3376 while (cell
< ncells
) {
3380 while (ccell
< ncells
) {
3381 if (str
[pos
] == '\0') {
3386 dlen
= cells
[ccell
].dlen
;
3388 if (str
[pos
] != *d
) {
3394 if (dlen
> len
- pos
)
3396 if (memcmp(str
+ pos
, d
, dlen
) != 0) {
3409 /* If not found this will be one past the end. */
3412 while (px
>= gd
->sx
) {
3420 /* Free cell data. */
3421 for (cell
= 0; cell
< ncells
; cell
++) {
3422 if (cells
[cell
].allocated
)
3423 free((void *)cells
[cell
].d
);
3429 window_copy_move_left(struct screen
*s
, u_int
*fx
, u_int
*fy
, int wrapflag
)
3431 if (*fx
== 0) { /* left */
3432 if (*fy
== 0) { /* top */
3434 *fx
= screen_size_x(s
) - 1;
3435 *fy
= screen_hsize(s
) + screen_size_y(s
) - 1;
3439 *fx
= screen_size_x(s
) - 1;
3446 window_copy_move_right(struct screen
*s
, u_int
*fx
, u_int
*fy
, int wrapflag
)
3448 if (*fx
== screen_size_x(s
) - 1) { /* right */
3449 if (*fy
== screen_hsize(s
) + screen_size_y(s
) - 1) { /* bottom */
3463 window_copy_is_lowercase(const char *ptr
)
3465 while (*ptr
!= '\0') {
3466 if (*ptr
!= tolower((u_char
)*ptr
))
3474 * Handle backward wrapped regex searches with overlapping matches. In this case
3475 * find the longest overlapping match from previous wrapped lines.
3478 window_copy_search_back_overlap(struct grid
*gd
, regex_t
*preg
, u_int
*ppx
,
3479 u_int
*psx
, u_int
*ppy
, u_int endline
)
3481 u_int endx
, endy
, oldendx
, oldendy
, px
, py
, sx
;
3484 oldendx
= *ppx
+ *psx
;
3486 while (oldendx
> gd
->sx
- 1) {
3494 while (found
&& px
== 0 && py
- 1 > endline
&&
3495 grid_get_line(gd
, py
- 2)->flags
& GRID_LINE_WRAPPED
&&
3496 endx
== oldendx
&& endy
== oldendy
) {
3498 found
= window_copy_search_rl_regex(gd
, &px
, &sx
, py
- 1, 0,
3503 while (endx
> gd
->sx
- 1) {
3507 if (endx
== oldendx
&& endy
== oldendy
) {
3516 * Search for text stored in sgd starting from position fx,fy up to endline. If
3517 * found, jump to it. If cis then ignore case. The direction is 0 for searching
3518 * up, down otherwise. If wrap then go to begin/end of grid and try again if
3522 window_copy_search_jump(struct window_mode_entry
*wme
, struct grid
*gd
,
3523 struct grid
*sgd
, u_int fx
, u_int fy
, u_int endline
, int cis
, int wrap
,
3524 int direction
, int regex
)
3526 u_int i
, px
, sx
, ssize
= 1;
3527 int found
= 0, cflags
= REG_EXTENDED
;
3532 sbuf
= xmalloc(ssize
);
3534 sbuf
= window_copy_stringify(sgd
, 0, 0, sgd
->sx
, sbuf
, &ssize
);
3536 cflags
|= REG_ICASE
;
3537 if (regcomp(®
, sbuf
, cflags
) != 0) {
3545 for (i
= fy
; i
<= endline
; i
++) {
3547 found
= window_copy_search_lr_regex(gd
,
3548 &px
, &sx
, i
, fx
, gd
->sx
, ®
);
3550 found
= window_copy_search_lr(gd
, sgd
,
3551 &px
, i
, fx
, gd
->sx
, cis
);
3558 for (i
= fy
+ 1; endline
< i
; i
--) {
3560 found
= window_copy_search_rl_regex(gd
,
3561 &px
, &sx
, i
- 1, 0, fx
+ 1, ®
);
3563 window_copy_search_back_overlap(gd
,
3564 ®
, &px
, &sx
, &i
, endline
);
3567 found
= window_copy_search_rl(gd
, sgd
,
3568 &px
, i
- 1, 0, fx
+ 1, cis
);
3581 window_copy_scroll_to(wme
, px
, i
, 1);
3585 return (window_copy_search_jump(wme
, gd
, sgd
,
3586 direction
? 0 : gd
->sx
- 1,
3587 direction
? 0 : gd
->hsize
+ gd
->sy
- 1, fy
, cis
, 0,
3594 window_copy_move_after_search_mark(struct window_copy_mode_data
*data
,
3595 u_int
*fx
, u_int
*fy
, int wrapflag
)
3597 struct screen
*s
= data
->backing
;
3600 if (window_copy_search_mark_at(data
, *fx
, *fy
, &start
) == 0 &&
3601 data
->searchmark
[start
] != 0) {
3602 while (window_copy_search_mark_at(data
, *fx
, *fy
, &at
) == 0) {
3603 if (data
->searchmark
[at
] != data
->searchmark
[start
])
3605 /* Stop if not wrapping and at the end of the grid. */
3607 *fx
== screen_size_x(s
) - 1 &&
3608 *fy
== screen_hsize(s
) + screen_size_y(s
) - 1)
3611 window_copy_move_right(s
, fx
, fy
, wrapflag
);
3617 * Search in for text searchstr. If direction is 0 then search up, otherwise
3621 window_copy_search(struct window_mode_entry
*wme
, int direction
, int regex
)
3623 struct window_pane
*wp
= wme
->wp
;
3624 struct window_copy_mode_data
*data
= wme
->data
;
3625 struct screen
*s
= data
->backing
, ss
;
3626 struct screen_write_ctx ctx
;
3627 struct grid
*gd
= s
->grid
;
3628 const char *str
= data
->searchstr
;
3629 u_int at
, endline
, fx
, fy
, start
;
3630 int cis
, found
, keys
, visible_only
;
3633 if (regex
&& str
[strcspn(str
, "^$*+()?[].\\")] == '\0')
3636 data
->searchdirection
= direction
;
3641 if (data
->searchall
|| wp
->searchstr
== NULL
||
3642 wp
->searchregex
!= regex
) {
3644 data
->searchall
= 0;
3646 visible_only
= (strcmp(wp
->searchstr
, str
) == 0);
3647 if (visible_only
== 0 && data
->searchmark
!= NULL
)
3648 window_copy_clear_marks(wme
);
3649 free(wp
->searchstr
);
3650 wp
->searchstr
= xstrdup(str
);
3651 wp
->searchregex
= regex
;
3654 fy
= screen_hsize(data
->backing
) - data
->oy
+ data
->cy
;
3656 screen_init(&ss
, screen_write_strlen("%s", str
), 1, 0);
3657 screen_write_start(&ctx
, &ss
);
3658 screen_write_nputs(&ctx
, -1, &grid_default_cell
, "%s", str
);
3659 screen_write_stop(&ctx
);
3661 wrapflag
= options_get_number(wp
->window
->options
, "wrap-search");
3662 cis
= window_copy_is_lowercase(str
);
3664 keys
= options_get_number(wp
->window
->options
, "mode-keys");
3668 * Behave according to mode-keys. If it is emacs, search forward
3669 * leaves the cursor after the match. If it is vi, the cursor
3670 * remains at the beginning of the match, regardless of
3671 * direction, which means that we need to start the next search
3672 * after the term the cursor is currently on when searching
3675 if (keys
== MODEKEY_VI
) {
3676 if (data
->searchmark
!= NULL
)
3677 window_copy_move_after_search_mark(data
, &fx
,
3681 * When there are no search marks, start the
3682 * search after the current cursor position.
3684 window_copy_move_right(s
, &fx
, &fy
, wrapflag
);
3687 endline
= gd
->hsize
+ gd
->sy
- 1;
3690 window_copy_move_left(s
, &fx
, &fy
, wrapflag
);
3694 found
= window_copy_search_jump(wme
, gd
, ss
.grid
, fx
, fy
, endline
, cis
,
3695 wrapflag
, direction
, regex
);
3697 window_copy_search_marks(wme
, &ss
, regex
, visible_only
);
3699 fy
= screen_hsize(data
->backing
) - data
->oy
+ data
->cy
;
3702 * When searching forward, if the cursor is not at the beginning
3703 * of the mark, search again.
3706 window_copy_search_mark_at(data
, fx
, fy
, &at
) == 0 &&
3708 data
->searchmark
!= NULL
&&
3709 data
->searchmark
[at
] == data
->searchmark
[at
- 1]) {
3710 window_copy_move_after_search_mark(data
, &fx
, &fy
,
3712 window_copy_search_jump(wme
, gd
, ss
.grid
, fx
,
3713 fy
, endline
, cis
, wrapflag
, direction
,
3716 fy
= screen_hsize(data
->backing
) - data
->oy
+ data
->cy
;
3721 * When in Emacs mode, position the cursor just after
3724 if (keys
== MODEKEY_EMACS
) {
3725 window_copy_move_after_search_mark(data
, &fx
,
3728 data
->cy
= fy
- screen_hsize(data
->backing
) +
3734 * When searching backward, position the cursor at the
3735 * beginning of the mark.
3737 if (window_copy_search_mark_at(data
, fx
, fy
,
3739 while (window_copy_search_mark_at(data
, fx
, fy
,
3741 data
->searchmark
!= NULL
&&
3742 data
->searchmark
[at
] ==
3743 data
->searchmark
[start
]) {
3746 screen_hsize(data
->backing
) +
3751 window_copy_move_left(s
, &fx
, &fy
, 0);
3756 window_copy_redraw_screen(wme
);
3763 window_copy_visible_lines(struct window_copy_mode_data
*data
, u_int
*start
,
3766 struct grid
*gd
= data
->backing
->grid
;
3767 const struct grid_line
*gl
;
3769 for (*start
= gd
->hsize
- data
->oy
; *start
> 0; (*start
)--) {
3770 gl
= grid_peek_line(gd
, (*start
) - 1);
3771 if (~gl
->flags
& GRID_LINE_WRAPPED
)
3774 *end
= gd
->hsize
- data
->oy
+ gd
->sy
;
3778 window_copy_search_mark_at(struct window_copy_mode_data
*data
, u_int px
,
3779 u_int py
, u_int
*at
)
3781 struct screen
*s
= data
->backing
;
3782 struct grid
*gd
= s
->grid
;
3784 if (py
< gd
->hsize
- data
->oy
)
3786 if (py
> gd
->hsize
- data
->oy
+ gd
->sy
- 1)
3788 *at
= ((py
- (gd
->hsize
- data
->oy
)) * gd
->sx
) + px
;
3793 window_copy_search_marks(struct window_mode_entry
*wme
, struct screen
*ssp
,
3794 int regex
, int visible_only
)
3796 struct window_copy_mode_data
*data
= wme
->data
;
3797 struct screen
*s
= data
->backing
, ss
;
3798 struct screen_write_ctx ctx
;
3799 struct grid
*gd
= s
->grid
;
3800 int found
, cis
, stopped
= 0;
3801 int cflags
= REG_EXTENDED
;
3802 u_int px
, py
, i
, b
, nfound
= 0, width
;
3803 u_int ssize
= 1, start
, end
;
3806 uint64_t stop
= 0, tstart
, t
;
3809 width
= screen_write_strlen("%s", data
->searchstr
);
3810 screen_init(&ss
, width
, 1, 0);
3811 screen_write_start(&ctx
, &ss
);
3812 screen_write_nputs(&ctx
, -1, &grid_default_cell
, "%s",
3814 screen_write_stop(&ctx
);
3817 width
= screen_size_x(ssp
);
3819 cis
= window_copy_is_lowercase(data
->searchstr
);
3822 sbuf
= xmalloc(ssize
);
3824 sbuf
= window_copy_stringify(ssp
->grid
, 0, 0, ssp
->grid
->sx
,
3827 cflags
|= REG_ICASE
;
3828 if (regcomp(®
, sbuf
, cflags
) != 0) {
3834 tstart
= get_timer();
3837 window_copy_visible_lines(data
, &start
, &end
);
3840 end
= gd
->hsize
+ gd
->sy
;
3841 stop
= get_timer() + WINDOW_COPY_SEARCH_ALL_TIMEOUT
;
3845 free(data
->searchmark
);
3846 data
->searchmark
= xcalloc(gd
->sx
, gd
->sy
);
3847 data
->searchgen
= 1;
3849 for (py
= start
; py
< end
; py
++) {
3853 found
= window_copy_search_lr_regex(gd
,
3854 &px
, &width
, py
, px
, gd
->sx
, ®
);
3858 found
= window_copy_search_lr(gd
, ssp
->grid
,
3859 &px
, py
, px
, gd
->sx
, cis
);
3865 if (window_copy_search_mark_at(data
, px
, py
, &b
) == 0) {
3866 if (b
+ width
> gd
->sx
* gd
->sy
)
3867 width
= (gd
->sx
* gd
->sy
) - b
;
3868 for (i
= b
; i
< b
+ width
; i
++) {
3869 if (data
->searchmark
[i
] != 0)
3871 data
->searchmark
[i
] = data
->searchgen
;
3873 if (data
->searchgen
== UCHAR_MAX
)
3874 data
->searchgen
= 1;
3882 if (t
- tstart
> WINDOW_COPY_SEARCH_TIMEOUT
) {
3886 if (stop
!= 0 && t
> stop
) {
3891 if (data
->timeout
) {
3892 window_copy_clear_marks(wme
);
3896 if (stopped
&& stop
!= 0) {
3897 /* Try again but just the visible context. */
3898 window_copy_visible_lines(data
, &start
, &end
);
3903 if (!visible_only
) {
3906 data
->searchcount
= 1000;
3907 else if (nfound
> 100)
3908 data
->searchcount
= 100;
3909 else if (nfound
> 10)
3910 data
->searchcount
= 10;
3912 data
->searchcount
= -1;
3913 data
->searchmore
= 1;
3915 data
->searchcount
= nfound
;
3916 data
->searchmore
= 0;
3929 window_copy_clear_marks(struct window_mode_entry
*wme
)
3931 struct window_copy_mode_data
*data
= wme
->data
;
3933 free(data
->searchmark
);
3934 data
->searchmark
= NULL
;
3938 window_copy_search_up(struct window_mode_entry
*wme
, int regex
)
3940 return (window_copy_search(wme
, 0, regex
));
3944 window_copy_search_down(struct window_mode_entry
*wme
, int regex
)
3946 return (window_copy_search(wme
, 1, regex
));
3950 window_copy_goto_line(struct window_mode_entry
*wme
, const char *linestr
)
3952 struct window_copy_mode_data
*data
= wme
->data
;
3956 lineno
= strtonum(linestr
, -1, INT_MAX
, &errstr
);
3959 if (lineno
< 0 || (u_int
)lineno
> screen_hsize(data
->backing
))
3960 lineno
= screen_hsize(data
->backing
);
3963 window_copy_update_selection(wme
, 1, 0);
3964 window_copy_redraw_screen(wme
);
3968 window_copy_match_start_end(struct window_copy_mode_data
*data
, u_int at
,
3969 u_int
*start
, u_int
*end
)
3971 struct grid
*gd
= data
->backing
->grid
;
3972 u_int last
= (gd
->sy
* gd
->sx
) - 1;
3973 u_char mark
= data
->searchmark
[at
];
3976 while (*start
!= 0 && data
->searchmark
[*start
] == mark
)
3978 if (data
->searchmark
[*start
] != mark
)
3980 while (*end
!= last
&& data
->searchmark
[*end
] == mark
)
3982 if (data
->searchmark
[*end
] != mark
)
3987 window_copy_match_at_cursor(struct window_copy_mode_data
*data
)
3989 struct grid
*gd
= data
->backing
->grid
;
3990 struct grid_cell gc
;
3991 u_int at
, start
, end
, cy
, px
, py
;
3992 u_int sx
= screen_size_x(data
->backing
);
3996 if (data
->searchmark
== NULL
)
3999 cy
= screen_hsize(data
->backing
) - data
->oy
+ data
->cy
;
4000 if (window_copy_search_mark_at(data
, data
->cx
, cy
, &at
) != 0)
4002 if (data
->searchmark
[at
] == 0) {
4003 /* Allow one position after the match. */
4004 if (at
== 0 || data
->searchmark
[--at
] == 0)
4007 window_copy_match_start_end(data
, at
, &start
, &end
);
4010 * Cells will not be set in the marked array unless they are valid text
4011 * and wrapping will be taken care of, so we can just copy.
4013 for (at
= start
; at
<= end
; at
++) {
4015 px
= at
- (py
* sx
);
4017 grid_get_cell(gd
, px
, gd
->hsize
+ py
- data
->oy
, &gc
);
4018 buf
= xrealloc(buf
, len
+ gc
.data
.size
+ 1);
4019 memcpy(buf
+ len
, gc
.data
.data
, gc
.data
.size
);
4020 len
+= gc
.data
.size
;
4028 window_copy_update_style(struct window_mode_entry
*wme
, u_int fx
, u_int fy
,
4029 struct grid_cell
*gc
, const struct grid_cell
*mgc
,
4030 const struct grid_cell
*cgc
, const struct grid_cell
*mkgc
)
4032 struct window_pane
*wp
= wme
->wp
;
4033 struct window_copy_mode_data
*data
= wme
->data
;
4034 u_int mark
, start
, end
, cy
, cursor
, current
;
4035 int inv
= 0, found
= 0;
4038 if (data
->showmark
&& fy
== data
->my
) {
4039 gc
->attr
= mkgc
->attr
;
4052 if (data
->searchmark
== NULL
)
4055 if (window_copy_search_mark_at(data
, fx
, fy
, ¤t
) != 0)
4057 mark
= data
->searchmark
[current
];
4061 cy
= screen_hsize(data
->backing
) - data
->oy
+ data
->cy
;
4062 if (window_copy_search_mark_at(data
, data
->cx
, cy
, &cursor
) == 0) {
4063 keys
= options_get_number(wp
->window
->options
, "mode-keys");
4065 keys
== MODEKEY_EMACS
&&
4066 data
->searchdirection
) {
4067 if (data
->searchmark
[cursor
- 1] == mark
) {
4071 } else if (data
->searchmark
[cursor
] == mark
)
4074 window_copy_match_start_end(data
, cursor
, &start
, &end
);
4075 if (current
>= start
&& current
<= end
) {
4076 gc
->attr
= cgc
->attr
;
4090 gc
->attr
= mgc
->attr
;
4102 window_copy_write_one(struct window_mode_entry
*wme
,
4103 struct screen_write_ctx
*ctx
, u_int py
, u_int fy
, u_int nx
,
4104 const struct grid_cell
*mgc
, const struct grid_cell
*cgc
,
4105 const struct grid_cell
*mkgc
)
4107 struct window_copy_mode_data
*data
= wme
->data
;
4108 struct grid
*gd
= data
->backing
->grid
;
4109 struct grid_cell gc
;
4112 screen_write_cursormove(ctx
, 0, py
, 0);
4113 for (fx
= 0; fx
< nx
; fx
++) {
4114 grid_get_cell(gd
, fx
, fy
, &gc
);
4115 if (fx
+ gc
.data
.width
<= nx
) {
4116 window_copy_update_style(wme
, fx
, fy
, &gc
, mgc
, cgc
,
4118 screen_write_cell(ctx
, &gc
);
4124 window_copy_write_line(struct window_mode_entry
*wme
,
4125 struct screen_write_ctx
*ctx
, u_int py
)
4127 struct window_pane
*wp
= wme
->wp
;
4128 struct window_copy_mode_data
*data
= wme
->data
;
4129 struct screen
*s
= &data
->screen
;
4130 struct options
*oo
= wp
->window
->options
;
4131 struct grid_line
*gl
;
4132 struct grid_cell gc
, mgc
, cgc
, mkgc
;
4133 char hdr
[512], tmp
[256], *t
;
4135 u_int hsize
= screen_hsize(data
->backing
);
4137 style_apply(&gc
, oo
, "mode-style", NULL
);
4138 gc
.flags
|= GRID_FLAG_NOPALETTE
;
4139 style_apply(&mgc
, oo
, "copy-mode-match-style", NULL
);
4140 mgc
.flags
|= GRID_FLAG_NOPALETTE
;
4141 style_apply(&cgc
, oo
, "copy-mode-current-match-style", NULL
);
4142 cgc
.flags
|= GRID_FLAG_NOPALETTE
;
4143 style_apply(&mkgc
, oo
, "copy-mode-mark-style", NULL
);
4144 mkgc
.flags
|= GRID_FLAG_NOPALETTE
;
4146 if (py
== 0 && s
->rupper
< s
->rlower
&& !data
->hide_position
) {
4147 gl
= grid_get_line(data
->backing
->grid
, hsize
- data
->oy
);
4149 xsnprintf(tmp
, sizeof tmp
, "[%u/%u]", data
->oy
, hsize
);
4151 t
= format_pretty_time(gl
->time
, 1);
4152 xsnprintf(tmp
, sizeof tmp
, "%s [%u/%u]", t
, data
->oy
,
4157 if (data
->searchmark
== NULL
) {
4158 if (data
->timeout
) {
4159 size
= xsnprintf(hdr
, sizeof hdr
,
4160 "(timed out) %s", tmp
);
4162 size
= xsnprintf(hdr
, sizeof hdr
, "%s", tmp
);
4164 if (data
->searchcount
== -1)
4165 size
= xsnprintf(hdr
, sizeof hdr
, "%s", tmp
);
4167 size
= xsnprintf(hdr
, sizeof hdr
,
4168 "(%d%s results) %s", data
->searchcount
,
4169 data
->searchmore
? "+" : "", tmp
);
4172 if (size
> screen_size_x(s
))
4173 size
= screen_size_x(s
);
4174 screen_write_cursormove(ctx
, screen_size_x(s
) - size
, 0, 0);
4175 screen_write_puts(ctx
, &gc
, "%s", hdr
);
4179 if (size
< screen_size_x(s
)) {
4180 window_copy_write_one(wme
, ctx
, py
, hsize
- data
->oy
+ py
,
4181 screen_size_x(s
) - size
, &mgc
, &cgc
, &mkgc
);
4184 if (py
== data
->cy
&& data
->cx
== screen_size_x(s
)) {
4185 screen_write_cursormove(ctx
, screen_size_x(s
) - 1, py
, 0);
4186 screen_write_putc(ctx
, &grid_default_cell
, '$');
4191 window_copy_write_lines(struct window_mode_entry
*wme
,
4192 struct screen_write_ctx
*ctx
, u_int py
, u_int ny
)
4196 for (yy
= py
; yy
< py
+ ny
; yy
++)
4197 window_copy_write_line(wme
, ctx
, py
);
4201 window_copy_redraw_selection(struct window_mode_entry
*wme
, u_int old_y
)
4203 struct window_copy_mode_data
*data
= wme
->data
;
4204 struct grid
*gd
= data
->backing
->grid
;
4205 u_int new_y
, start
, end
;
4208 if (old_y
<= new_y
) {
4217 * In word selection mode the first word on the line below the cursor
4218 * might be selected, so add this line to the redraw area.
4220 if (data
->selflag
== SEL_WORD
) {
4221 /* Last grid line in data coordinates. */
4222 if (end
< gd
->sy
+ data
->oy
- 1)
4225 window_copy_redraw_lines(wme
, start
, end
- start
+ 1);
4229 window_copy_redraw_lines(struct window_mode_entry
*wme
, u_int py
, u_int ny
)
4231 struct window_pane
*wp
= wme
->wp
;
4232 struct window_copy_mode_data
*data
= wme
->data
;
4233 struct screen_write_ctx ctx
;
4236 screen_write_start_pane(&ctx
, wp
, NULL
);
4237 for (i
= py
; i
< py
+ ny
; i
++)
4238 window_copy_write_line(wme
, &ctx
, i
);
4239 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
, 0);
4240 screen_write_stop(&ctx
);
4244 window_copy_redraw_screen(struct window_mode_entry
*wme
)
4246 struct window_copy_mode_data
*data
= wme
->data
;
4248 window_copy_redraw_lines(wme
, 0, screen_size_y(&data
->screen
));
4252 window_copy_synchronize_cursor_end(struct window_mode_entry
*wme
, int begin
,
4255 struct window_copy_mode_data
*data
= wme
->data
;
4259 yy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
4260 switch (data
->selflag
) {
4265 if (data
->dy
> yy
|| (data
->dy
== yy
&& data
->dx
> xx
)) {
4266 /* Right to left selection. */
4267 window_copy_cursor_previous_word_pos(wme
,
4268 data
->separators
, &xx
, &yy
);
4271 /* Reset the end. */
4272 data
->endselx
= data
->endselrx
;
4273 data
->endsely
= data
->endselry
;
4275 /* Left to right selection. */
4276 if (xx
>= window_copy_find_length(wme
, yy
) ||
4277 !window_copy_in_set(wme
, xx
+ 1, yy
, WHITESPACE
)) {
4278 window_copy_cursor_next_word_end_pos(wme
,
4279 data
->separators
, &xx
, &yy
);
4282 /* Reset the start. */
4283 data
->selx
= data
->selrx
;
4284 data
->sely
= data
->selry
;
4291 if (data
->dy
> yy
) {
4292 /* Right to left selection. */
4296 /* Reset the end. */
4297 data
->endselx
= data
->endselrx
;
4298 data
->endsely
= data
->endselry
;
4300 /* Left to right selection. */
4301 if (yy
< data
->endselry
)
4302 yy
= data
->endselry
;
4303 xx
= window_copy_find_length(wme
, yy
);
4305 /* Reset the start. */
4306 data
->selx
= data
->selrx
;
4307 data
->sely
= data
->selry
;
4323 window_copy_synchronize_cursor(struct window_mode_entry
*wme
, int no_reset
)
4325 struct window_copy_mode_data
*data
= wme
->data
;
4327 switch (data
->cursordrag
) {
4328 case CURSORDRAG_ENDSEL
:
4329 window_copy_synchronize_cursor_end(wme
, 0, no_reset
);
4331 case CURSORDRAG_SEL
:
4332 window_copy_synchronize_cursor_end(wme
, 1, no_reset
);
4334 case CURSORDRAG_NONE
:
4340 window_copy_update_cursor(struct window_mode_entry
*wme
, u_int cx
, u_int cy
)
4342 struct window_pane
*wp
= wme
->wp
;
4343 struct window_copy_mode_data
*data
= wme
->data
;
4344 struct screen
*s
= &data
->screen
;
4345 struct screen_write_ctx ctx
;
4346 u_int old_cx
, old_cy
;
4348 old_cx
= data
->cx
; old_cy
= data
->cy
;
4349 data
->cx
= cx
; data
->cy
= cy
;
4350 if (old_cx
== screen_size_x(s
))
4351 window_copy_redraw_lines(wme
, old_cy
, 1);
4352 if (data
->cx
== screen_size_x(s
))
4353 window_copy_redraw_lines(wme
, data
->cy
, 1);
4355 screen_write_start_pane(&ctx
, wp
, NULL
);
4356 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
, 0);
4357 screen_write_stop(&ctx
);
4362 window_copy_start_selection(struct window_mode_entry
*wme
)
4364 struct window_copy_mode_data
*data
= wme
->data
;
4366 data
->selx
= data
->cx
;
4367 data
->sely
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
4369 data
->endselx
= data
->selx
;
4370 data
->endsely
= data
->sely
;
4372 data
->cursordrag
= CURSORDRAG_ENDSEL
;
4374 window_copy_set_selection(wme
, 1, 0);
4378 window_copy_adjust_selection(struct window_mode_entry
*wme
, u_int
*selx
,
4381 struct window_copy_mode_data
*data
= wme
->data
;
4382 struct screen
*s
= &data
->screen
;
4389 ty
= screen_hsize(data
->backing
) - data
->oy
;
4391 relpos
= WINDOW_COPY_REL_POS_ABOVE
;
4392 if (!data
->rectflag
)
4395 } else if (sy
> ty
+ screen_size_y(s
) - 1) {
4396 relpos
= WINDOW_COPY_REL_POS_BELOW
;
4397 if (!data
->rectflag
)
4398 sx
= screen_size_x(s
) - 1;
4399 sy
= screen_size_y(s
) - 1;
4401 relpos
= WINDOW_COPY_REL_POS_ON_SCREEN
;
4411 window_copy_update_selection(struct window_mode_entry
*wme
, int may_redraw
,
4414 struct window_copy_mode_data
*data
= wme
->data
;
4415 struct screen
*s
= &data
->screen
;
4417 if (s
->sel
== NULL
&& data
->lineflag
== LINE_SEL_NONE
)
4419 return (window_copy_set_selection(wme
, may_redraw
, no_reset
));
4423 window_copy_set_selection(struct window_mode_entry
*wme
, int may_redraw
,
4426 struct window_pane
*wp
= wme
->wp
;
4427 struct window_copy_mode_data
*data
= wme
->data
;
4428 struct screen
*s
= &data
->screen
;
4429 struct options
*oo
= wp
->window
->options
;
4430 struct grid_cell gc
;
4431 u_int sx
, sy
, cy
, endsx
, endsy
;
4432 int startrelpos
, endrelpos
;
4434 window_copy_synchronize_cursor(wme
, no_reset
);
4436 /* Adjust the selection. */
4439 startrelpos
= window_copy_adjust_selection(wme
, &sx
, &sy
);
4441 /* Adjust the end of selection. */
4442 endsx
= data
->endselx
;
4443 endsy
= data
->endsely
;
4444 endrelpos
= window_copy_adjust_selection(wme
, &endsx
, &endsy
);
4446 /* Selection is outside of the current screen */
4447 if (startrelpos
== endrelpos
&&
4448 startrelpos
!= WINDOW_COPY_REL_POS_ON_SCREEN
) {
4449 screen_hide_selection(s
);
4453 /* Set colours and selection. */
4454 style_apply(&gc
, oo
, "mode-style", NULL
);
4455 gc
.flags
|= GRID_FLAG_NOPALETTE
;
4456 screen_set_selection(s
, sx
, sy
, endsx
, endsy
, data
->rectflag
,
4457 data
->modekeys
, &gc
);
4459 if (data
->rectflag
&& may_redraw
) {
4461 * Can't rely on the caller to redraw the right lines for
4462 * rectangle selection - find the highest line and the number
4463 * of lines, and redraw just past that in both directions
4466 if (data
->cursordrag
== CURSORDRAG_ENDSEL
) {
4468 window_copy_redraw_lines(wme
, sy
, cy
- sy
+ 1);
4470 window_copy_redraw_lines(wme
, cy
, sy
- cy
+ 1);
4473 window_copy_redraw_lines(wme
, endsy
,
4476 window_copy_redraw_lines(wme
, cy
,
4486 window_copy_get_selection(struct window_mode_entry
*wme
, size_t *len
)
4488 struct window_pane
*wp
= wme
->wp
;
4489 struct window_copy_mode_data
*data
= wme
->data
;
4490 struct screen
*s
= &data
->screen
;
4493 u_int i
, xx
, yy
, sx
, sy
, ex
, ey
, ey_last
;
4494 u_int firstsx
, lastex
, restex
, restsx
, selx
;
4497 if (data
->screen
.sel
== NULL
&& data
->lineflag
== LINE_SEL_NONE
) {
4498 buf
= window_copy_match_at_cursor(data
);
4512 * The selection extends from selx,sely to (adjusted) cx,cy on
4516 /* Find start and end. */
4519 if (yy
< data
->sely
|| (yy
== data
->sely
&& xx
< data
->selx
)) {
4521 ex
= data
->selx
; ey
= data
->sely
;
4523 sx
= data
->selx
; sy
= data
->sely
;
4527 /* Trim ex to end of line. */
4528 ey_last
= window_copy_find_length(wme
, ey
);
4533 * Deal with rectangle-copy if necessary; four situations: start of
4534 * first line (firstsx), end of last line (lastex), start (restsx) and
4535 * end (restex) of all other lines.
4537 xx
= screen_size_x(s
);
4540 * Behave according to mode-keys. If it is emacs, copy like emacs,
4541 * keeping the top-left-most character, and dropping the
4542 * bottom-right-most, regardless of copy direction. If it is vi, also
4543 * keep bottom-right-most character.
4545 keys
= options_get_number(wp
->window
->options
, "mode-keys");
4546 if (data
->rectflag
) {
4548 * Need to ignore the column with the cursor in it, which for
4549 * rectangular copy means knowing which side the cursor is on.
4551 if (data
->cursordrag
== CURSORDRAG_ENDSEL
)
4554 selx
= data
->endselx
;
4555 if (selx
< data
->cx
) {
4556 /* Selection start is on the left. */
4557 if (keys
== MODEKEY_EMACS
) {
4562 lastex
= data
->cx
+ 1;
4563 restex
= data
->cx
+ 1;
4568 /* Cursor is on the left. */
4575 if (keys
== MODEKEY_EMACS
)
4584 /* Copy the lines. */
4585 for (i
= sy
; i
<= ey
; i
++) {
4586 window_copy_copy_line(wme
, &buf
, &off
, i
,
4587 (i
== sy
? firstsx
: restsx
),
4588 (i
== ey
? lastex
: restex
));
4591 /* Don't bother if no data. */
4597 /* Remove final \n (unless at end in vi mode). */
4598 if (keys
== MODEKEY_EMACS
|| lastex
<= ey_last
) {
4599 if (~grid_get_line(data
->backing
->grid
, ey
)->flags
&
4600 GRID_LINE_WRAPPED
|| lastex
!= ey_last
)
4608 window_copy_copy_buffer(struct window_mode_entry
*wme
, const char *prefix
,
4609 void *buf
, size_t len
)
4611 struct window_pane
*wp
= wme
->wp
;
4612 struct screen_write_ctx ctx
;
4614 if (options_get_number(global_options
, "set-clipboard") != 0) {
4615 screen_write_start_pane(&ctx
, wp
, NULL
);
4616 screen_write_setselection(&ctx
, "", buf
, len
);
4617 screen_write_stop(&ctx
);
4618 notify_pane("pane-set-clipboard", wp
);
4621 paste_add(prefix
, buf
, len
);
4625 window_copy_pipe_run(struct window_mode_entry
*wme
, struct session
*s
,
4626 const char *cmd
, size_t *len
)
4631 buf
= window_copy_get_selection(wme
, len
);
4632 if (cmd
== NULL
|| *cmd
== '\0')
4633 cmd
= options_get_string(global_options
, "copy-command");
4634 if (cmd
!= NULL
&& *cmd
!= '\0') {
4635 job
= job_run(cmd
, 0, NULL
, NULL
, s
, NULL
, NULL
, NULL
, NULL
,
4636 NULL
, JOB_NOWAIT
, -1, -1);
4637 bufferevent_write(job_get_event(job
), buf
, *len
);
4643 window_copy_pipe(struct window_mode_entry
*wme
, struct session
*s
,
4648 window_copy_pipe_run(wme
, s
, cmd
, &len
);
4652 window_copy_copy_pipe(struct window_mode_entry
*wme
, struct session
*s
,
4653 const char *prefix
, const char *cmd
)
4658 buf
= window_copy_pipe_run(wme
, s
, cmd
, &len
);
4660 window_copy_copy_buffer(wme
, prefix
, buf
, len
);
4664 window_copy_copy_selection(struct window_mode_entry
*wme
, const char *prefix
)
4669 buf
= window_copy_get_selection(wme
, &len
);
4671 window_copy_copy_buffer(wme
, prefix
, buf
, len
);
4675 window_copy_append_selection(struct window_mode_entry
*wme
)
4677 struct window_pane
*wp
= wme
->wp
;
4679 struct paste_buffer
*pb
;
4680 const char *bufdata
, *bufname
= NULL
;
4681 size_t len
, bufsize
;
4682 struct screen_write_ctx ctx
;
4684 buf
= window_copy_get_selection(wme
, &len
);
4688 if (options_get_number(global_options
, "set-clipboard") != 0) {
4689 screen_write_start_pane(&ctx
, wp
, NULL
);
4690 screen_write_setselection(&ctx
, "", buf
, len
);
4691 screen_write_stop(&ctx
);
4692 notify_pane("pane-set-clipboard", wp
);
4695 pb
= paste_get_top(&bufname
);
4697 bufdata
= paste_buffer_data(pb
, &bufsize
);
4698 buf
= xrealloc(buf
, len
+ bufsize
);
4699 memmove(buf
+ bufsize
, buf
, len
);
4700 memcpy(buf
, bufdata
, bufsize
);
4703 if (paste_set(buf
, len
, bufname
, NULL
) != 0)
4708 window_copy_copy_line(struct window_mode_entry
*wme
, char **buf
, size_t *off
,
4709 u_int sy
, u_int sx
, u_int ex
)
4711 struct window_copy_mode_data
*data
= wme
->data
;
4712 struct grid
*gd
= data
->backing
->grid
;
4713 struct grid_cell gc
;
4714 struct grid_line
*gl
;
4715 struct utf8_data ud
;
4716 u_int i
, xx
, wrapped
= 0;
4723 * Work out if the line was wrapped at the screen edge and all of it is
4726 gl
= grid_get_line(gd
, sy
);
4727 if (gl
->flags
& GRID_LINE_WRAPPED
&& gl
->cellsize
<= gd
->sx
)
4730 /* If the line was wrapped, don't strip spaces (use the full length). */
4734 xx
= window_copy_find_length(wme
, sy
);
4741 for (i
= sx
; i
< ex
; i
++) {
4742 grid_get_cell(gd
, i
, sy
, &gc
);
4743 if (gc
.flags
& GRID_FLAG_PADDING
)
4745 utf8_copy(&ud
, &gc
.data
);
4746 if (ud
.size
== 1 && (gc
.attr
& GRID_ATTR_CHARSET
)) {
4747 s
= tty_acs_get(NULL
, ud
.data
[0]);
4748 if (s
!= NULL
&& strlen(s
) <= sizeof ud
.data
) {
4749 ud
.size
= strlen(s
);
4750 memcpy(ud
.data
, s
, ud
.size
);
4754 *buf
= xrealloc(*buf
, (*off
) + ud
.size
);
4755 memcpy(*buf
+ *off
, ud
.data
, ud
.size
);
4760 /* Only add a newline if the line wasn't wrapped. */
4761 if (!wrapped
|| ex
!= xx
) {
4762 *buf
= xrealloc(*buf
, (*off
) + 1);
4763 (*buf
)[(*off
)++] = '\n';
4768 window_copy_clear_selection(struct window_mode_entry
*wme
)
4770 struct window_copy_mode_data
*data
= wme
->data
;
4773 screen_clear_selection(&data
->screen
);
4775 data
->cursordrag
= CURSORDRAG_NONE
;
4776 data
->lineflag
= LINE_SEL_NONE
;
4777 data
->selflag
= SEL_CHAR
;
4779 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
4780 px
= window_copy_find_length(wme
, py
);
4782 window_copy_update_cursor(wme
, px
, data
->cy
);
4786 window_copy_in_set(struct window_mode_entry
*wme
, u_int px
, u_int py
,
4789 struct window_copy_mode_data
*data
= wme
->data
;
4790 struct grid_cell gc
;
4792 grid_get_cell(data
->backing
->grid
, px
, py
, &gc
);
4793 if (gc
.flags
& GRID_FLAG_PADDING
)
4795 return (utf8_cstrhas(set
, &gc
.data
));
4799 window_copy_find_length(struct window_mode_entry
*wme
, u_int py
)
4801 struct window_copy_mode_data
*data
= wme
->data
;
4803 return (grid_line_length(data
->backing
->grid
, py
));
4807 window_copy_cursor_start_of_line(struct window_mode_entry
*wme
)
4809 struct window_copy_mode_data
*data
= wme
->data
;
4810 struct screen
*back_s
= data
->backing
;
4811 struct grid_reader gr
;
4812 u_int px
, py
, oldy
, hsize
;
4815 hsize
= screen_hsize(back_s
);
4816 py
= hsize
+ data
->cy
- data
->oy
;
4819 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
4820 grid_reader_cursor_start_of_line(&gr
, 1);
4821 grid_reader_get_cursor(&gr
, &px
, &py
);
4822 window_copy_acquire_cursor_up(wme
, hsize
, data
->oy
, oldy
, px
, py
);
4826 window_copy_cursor_back_to_indentation(struct window_mode_entry
*wme
)
4828 struct window_copy_mode_data
*data
= wme
->data
;
4829 struct screen
*back_s
= data
->backing
;
4830 struct grid_reader gr
;
4831 u_int px
, py
, oldy
, hsize
;
4834 hsize
= screen_hsize(back_s
);
4835 py
= hsize
+ data
->cy
- data
->oy
;
4838 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
4839 grid_reader_cursor_back_to_indentation(&gr
);
4840 grid_reader_get_cursor(&gr
, &px
, &py
);
4841 window_copy_acquire_cursor_up(wme
, hsize
, data
->oy
, oldy
, px
, py
);
4845 window_copy_cursor_end_of_line(struct window_mode_entry
*wme
)
4847 struct window_copy_mode_data
*data
= wme
->data
;
4848 struct screen
*back_s
= data
->backing
;
4849 struct grid_reader gr
;
4850 u_int px
, py
, oldy
, hsize
;
4853 hsize
= screen_hsize(back_s
);
4854 py
= hsize
+ data
->cy
- data
->oy
;
4857 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
4858 if (data
->screen
.sel
!= NULL
&& data
->rectflag
)
4859 grid_reader_cursor_end_of_line(&gr
, 1, 1);
4861 grid_reader_cursor_end_of_line(&gr
, 1, 0);
4862 grid_reader_get_cursor(&gr
, &px
, &py
);
4863 window_copy_acquire_cursor_down(wme
, hsize
, screen_size_y(back_s
),
4864 data
->oy
, oldy
, px
, py
, 0);
4868 window_copy_other_end(struct window_mode_entry
*wme
)
4870 struct window_copy_mode_data
*data
= wme
->data
;
4871 struct screen
*s
= &data
->screen
;
4872 u_int selx
, sely
, cy
, yy
, hsize
;
4874 if (s
->sel
== NULL
&& data
->lineflag
== LINE_SEL_NONE
)
4877 if (data
->lineflag
== LINE_SEL_LEFT_RIGHT
)
4878 data
->lineflag
= LINE_SEL_RIGHT_LEFT
;
4879 else if (data
->lineflag
== LINE_SEL_RIGHT_LEFT
)
4880 data
->lineflag
= LINE_SEL_LEFT_RIGHT
;
4882 switch (data
->cursordrag
) {
4883 case CURSORDRAG_NONE
:
4884 case CURSORDRAG_SEL
:
4885 data
->cursordrag
= CURSORDRAG_ENDSEL
;
4887 case CURSORDRAG_ENDSEL
:
4888 data
->cursordrag
= CURSORDRAG_SEL
;
4892 selx
= data
->endselx
;
4893 sely
= data
->endsely
;
4894 if (data
->cursordrag
== CURSORDRAG_SEL
) {
4900 yy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
4904 hsize
= screen_hsize(data
->backing
);
4905 if (sely
< hsize
- data
->oy
) { /* above */
4906 data
->oy
= hsize
- sely
;
4908 } else if (sely
> hsize
- data
->oy
+ screen_size_y(s
)) { /* below */
4909 data
->oy
= hsize
- sely
+ screen_size_y(s
) - 1;
4910 data
->cy
= screen_size_y(s
) - 1;
4912 data
->cy
= cy
+ sely
- yy
;
4914 window_copy_update_selection(wme
, 1, 1);
4915 window_copy_redraw_screen(wme
);
4919 window_copy_cursor_left(struct window_mode_entry
*wme
)
4921 struct window_copy_mode_data
*data
= wme
->data
;
4922 struct screen
*back_s
= data
->backing
;
4923 struct grid_reader gr
;
4924 u_int px
, py
, oldy
, hsize
;
4927 hsize
= screen_hsize(back_s
);
4928 py
= hsize
+ data
->cy
- data
->oy
;
4931 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
4932 grid_reader_cursor_left(&gr
, 1);
4933 grid_reader_get_cursor(&gr
, &px
, &py
);
4934 window_copy_acquire_cursor_up(wme
, hsize
, data
->oy
, oldy
, px
, py
);
4938 window_copy_cursor_right(struct window_mode_entry
*wme
, int all
)
4940 struct window_copy_mode_data
*data
= wme
->data
;
4941 struct screen
*back_s
= data
->backing
;
4942 struct grid_reader gr
;
4943 u_int px
, py
, oldy
, hsize
;
4946 hsize
= screen_hsize(back_s
);
4947 py
= hsize
+ data
->cy
- data
->oy
;
4950 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
4951 grid_reader_cursor_right(&gr
, 1, all
);
4952 grid_reader_get_cursor(&gr
, &px
, &py
);
4953 window_copy_acquire_cursor_down(wme
, hsize
, screen_size_y(back_s
),
4954 data
->oy
, oldy
, px
, py
, 0);
4958 window_copy_cursor_up(struct window_mode_entry
*wme
, int scroll_only
)
4960 struct window_copy_mode_data
*data
= wme
->data
;
4961 struct screen
*s
= &data
->screen
;
4962 u_int ox
, oy
, px
, py
;
4965 norectsel
= data
->screen
.sel
== NULL
|| !data
->rectflag
;
4966 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
4967 ox
= window_copy_find_length(wme
, oy
);
4968 if (norectsel
&& data
->cx
!= ox
) {
4969 data
->lastcx
= data
->cx
;
4973 if (data
->lineflag
== LINE_SEL_LEFT_RIGHT
&& oy
== data
->sely
)
4974 window_copy_other_end(wme
);
4976 if (scroll_only
|| data
->cy
== 0) {
4978 data
->cx
= data
->lastcx
;
4979 window_copy_scroll_down(wme
, 1);
4981 if (data
->cy
== screen_size_y(s
) - 1)
4982 window_copy_redraw_lines(wme
, data
->cy
, 1);
4984 window_copy_redraw_lines(wme
, data
->cy
, 2);
4988 window_copy_update_cursor(wme
, data
->lastcx
,
4991 window_copy_update_cursor(wme
, data
->cx
, data
->cy
- 1);
4992 if (window_copy_update_selection(wme
, 1, 0)) {
4993 if (data
->cy
== screen_size_y(s
) - 1)
4994 window_copy_redraw_lines(wme
, data
->cy
, 1);
4996 window_copy_redraw_lines(wme
, data
->cy
, 2);
5001 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5002 px
= window_copy_find_length(wme
, py
);
5003 if ((data
->cx
>= data
->lastsx
&& data
->cx
!= px
) ||
5006 window_copy_update_cursor(wme
, px
, data
->cy
);
5007 if (window_copy_update_selection(wme
, 1, 0))
5008 window_copy_redraw_lines(wme
, data
->cy
, 1);
5012 if (data
->lineflag
== LINE_SEL_LEFT_RIGHT
)
5014 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5016 px
= screen_size_x(data
->backing
);
5018 px
= window_copy_find_length(wme
, py
);
5019 window_copy_update_cursor(wme
, px
, data
->cy
);
5020 if (window_copy_update_selection(wme
, 1, 0))
5021 window_copy_redraw_lines(wme
, data
->cy
, 1);
5023 else if (data
->lineflag
== LINE_SEL_RIGHT_LEFT
)
5025 window_copy_update_cursor(wme
, 0, data
->cy
);
5026 if (window_copy_update_selection(wme
, 1, 0))
5027 window_copy_redraw_lines(wme
, data
->cy
, 1);
5032 window_copy_cursor_down(struct window_mode_entry
*wme
, int scroll_only
)
5034 struct window_copy_mode_data
*data
= wme
->data
;
5035 struct screen
*s
= &data
->screen
;
5036 u_int ox
, oy
, px
, py
;
5039 norectsel
= data
->screen
.sel
== NULL
|| !data
->rectflag
;
5040 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5041 ox
= window_copy_find_length(wme
, oy
);
5042 if (norectsel
&& data
->cx
!= ox
) {
5043 data
->lastcx
= data
->cx
;
5047 if (data
->lineflag
== LINE_SEL_RIGHT_LEFT
&& oy
== data
->endsely
)
5048 window_copy_other_end(wme
);
5050 if (scroll_only
|| data
->cy
== screen_size_y(s
) - 1) {
5052 data
->cx
= data
->lastcx
;
5053 window_copy_scroll_up(wme
, 1);
5054 if (scroll_only
&& data
->cy
> 0)
5055 window_copy_redraw_lines(wme
, data
->cy
- 1, 2);
5058 window_copy_update_cursor(wme
, data
->lastcx
,
5061 window_copy_update_cursor(wme
, data
->cx
, data
->cy
+ 1);
5062 if (window_copy_update_selection(wme
, 1, 0))
5063 window_copy_redraw_lines(wme
, data
->cy
- 1, 2);
5067 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5068 px
= window_copy_find_length(wme
, py
);
5069 if ((data
->cx
>= data
->lastsx
&& data
->cx
!= px
) ||
5072 window_copy_update_cursor(wme
, px
, data
->cy
);
5073 if (window_copy_update_selection(wme
, 1, 0))
5074 window_copy_redraw_lines(wme
, data
->cy
, 1);
5078 if (data
->lineflag
== LINE_SEL_LEFT_RIGHT
)
5080 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5082 px
= screen_size_x(data
->backing
);
5084 px
= window_copy_find_length(wme
, py
);
5085 window_copy_update_cursor(wme
, px
, data
->cy
);
5086 if (window_copy_update_selection(wme
, 1, 0))
5087 window_copy_redraw_lines(wme
, data
->cy
, 1);
5089 else if (data
->lineflag
== LINE_SEL_RIGHT_LEFT
)
5091 window_copy_update_cursor(wme
, 0, data
->cy
);
5092 if (window_copy_update_selection(wme
, 1, 0))
5093 window_copy_redraw_lines(wme
, data
->cy
, 1);
5098 window_copy_cursor_jump(struct window_mode_entry
*wme
)
5100 struct window_copy_mode_data
*data
= wme
->data
;
5101 struct screen
*back_s
= data
->backing
;
5102 struct grid_reader gr
;
5103 u_int px
, py
, oldy
, hsize
;
5106 hsize
= screen_hsize(back_s
);
5107 py
= hsize
+ data
->cy
- data
->oy
;
5110 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5111 if (grid_reader_cursor_jump(&gr
, data
->jumpchar
)) {
5112 grid_reader_get_cursor(&gr
, &px
, &py
);
5113 window_copy_acquire_cursor_down(wme
, hsize
,
5114 screen_size_y(back_s
), data
->oy
, oldy
, px
, py
, 0);
5119 window_copy_cursor_jump_back(struct window_mode_entry
*wme
)
5121 struct window_copy_mode_data
*data
= wme
->data
;
5122 struct screen
*back_s
= data
->backing
;
5123 struct grid_reader gr
;
5124 u_int px
, py
, oldy
, hsize
;
5127 hsize
= screen_hsize(back_s
);
5128 py
= hsize
+ data
->cy
- data
->oy
;
5131 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5132 grid_reader_cursor_left(&gr
, 0);
5133 if (grid_reader_cursor_jump_back(&gr
, data
->jumpchar
)) {
5134 grid_reader_get_cursor(&gr
, &px
, &py
);
5135 window_copy_acquire_cursor_up(wme
, hsize
, data
->oy
, oldy
, px
,
5141 window_copy_cursor_jump_to(struct window_mode_entry
*wme
)
5143 struct window_copy_mode_data
*data
= wme
->data
;
5144 struct screen
*back_s
= data
->backing
;
5145 struct grid_reader gr
;
5146 u_int px
, py
, oldy
, hsize
;
5149 hsize
= screen_hsize(back_s
);
5150 py
= hsize
+ data
->cy
- data
->oy
;
5153 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5154 if (grid_reader_cursor_jump(&gr
, data
->jumpchar
)) {
5155 grid_reader_cursor_left(&gr
, 1);
5156 grid_reader_get_cursor(&gr
, &px
, &py
);
5157 window_copy_acquire_cursor_down(wme
, hsize
,
5158 screen_size_y(back_s
), data
->oy
, oldy
, px
, py
, 0);
5163 window_copy_cursor_jump_to_back(struct window_mode_entry
*wme
)
5165 struct window_copy_mode_data
*data
= wme
->data
;
5166 struct screen
*back_s
= data
->backing
;
5167 struct grid_reader gr
;
5168 u_int px
, py
, oldy
, hsize
;
5171 hsize
= screen_hsize(back_s
);
5172 py
= hsize
+ data
->cy
- data
->oy
;
5175 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5176 grid_reader_cursor_left(&gr
, 0);
5177 grid_reader_cursor_left(&gr
, 0);
5178 if (grid_reader_cursor_jump_back(&gr
, data
->jumpchar
)) {
5179 grid_reader_cursor_right(&gr
, 1, 0);
5180 grid_reader_get_cursor(&gr
, &px
, &py
);
5181 window_copy_acquire_cursor_up(wme
, hsize
, data
->oy
, oldy
, px
,
5187 window_copy_cursor_next_word(struct window_mode_entry
*wme
,
5188 const char *separators
)
5190 struct window_copy_mode_data
*data
= wme
->data
;
5191 struct screen
*back_s
= data
->backing
;
5192 struct grid_reader gr
;
5193 u_int px
, py
, oldy
, hsize
;
5196 hsize
= screen_hsize(back_s
);
5197 py
= hsize
+ data
->cy
- data
->oy
;
5200 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5201 grid_reader_cursor_next_word(&gr
, separators
);
5202 grid_reader_get_cursor(&gr
, &px
, &py
);
5203 window_copy_acquire_cursor_down(wme
, hsize
, screen_size_y(back_s
),
5204 data
->oy
, oldy
, px
, py
, 0);
5207 /* Compute the next place where a word ends. */
5209 window_copy_cursor_next_word_end_pos(struct window_mode_entry
*wme
,
5210 const char *separators
, u_int
*ppx
, u_int
*ppy
)
5212 struct window_pane
*wp
= wme
->wp
;
5213 struct window_copy_mode_data
*data
= wme
->data
;
5214 struct options
*oo
= wp
->window
->options
;
5215 struct screen
*back_s
= data
->backing
;
5216 struct grid_reader gr
;
5217 u_int px
, py
, hsize
;
5220 hsize
= screen_hsize(back_s
);
5221 py
= hsize
+ data
->cy
- data
->oy
;
5223 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5224 if (options_get_number(oo
, "mode-keys") == MODEKEY_VI
) {
5225 if (!grid_reader_in_set(&gr
, WHITESPACE
))
5226 grid_reader_cursor_right(&gr
, 0, 0);
5227 grid_reader_cursor_next_word_end(&gr
, separators
);
5228 grid_reader_cursor_left(&gr
, 1);
5230 grid_reader_cursor_next_word_end(&gr
, separators
);
5231 grid_reader_get_cursor(&gr
, &px
, &py
);
5236 /* Move to the next place where a word ends. */
5238 window_copy_cursor_next_word_end(struct window_mode_entry
*wme
,
5239 const char *separators
, int no_reset
)
5241 struct window_pane
*wp
= wme
->wp
;
5242 struct window_copy_mode_data
*data
= wme
->data
;
5243 struct options
*oo
= wp
->window
->options
;
5244 struct screen
*back_s
= data
->backing
;
5245 struct grid_reader gr
;
5246 u_int px
, py
, oldy
, hsize
;
5249 hsize
= screen_hsize(back_s
);
5250 py
= hsize
+ data
->cy
- data
->oy
;
5253 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5254 if (options_get_number(oo
, "mode-keys") == MODEKEY_VI
) {
5255 if (!grid_reader_in_set(&gr
, WHITESPACE
))
5256 grid_reader_cursor_right(&gr
, 0, 0);
5257 grid_reader_cursor_next_word_end(&gr
, separators
);
5258 grid_reader_cursor_left(&gr
, 1);
5260 grid_reader_cursor_next_word_end(&gr
, separators
);
5261 grid_reader_get_cursor(&gr
, &px
, &py
);
5262 window_copy_acquire_cursor_down(wme
, hsize
, screen_size_y(back_s
),
5263 data
->oy
, oldy
, px
, py
, no_reset
);
5266 /* Compute the previous place where a word begins. */
5268 window_copy_cursor_previous_word_pos(struct window_mode_entry
*wme
,
5269 const char *separators
, u_int
*ppx
, u_int
*ppy
)
5271 struct window_copy_mode_data
*data
= wme
->data
;
5272 struct screen
*back_s
= data
->backing
;
5273 struct grid_reader gr
;
5274 u_int px
, py
, hsize
;
5277 hsize
= screen_hsize(back_s
);
5278 py
= hsize
+ data
->cy
- data
->oy
;
5280 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5281 grid_reader_cursor_previous_word(&gr
, separators
, /* already= */ 0,
5282 /* stop_at_eol= */ 1);
5283 grid_reader_get_cursor(&gr
, &px
, &py
);
5288 /* Move to the previous place where a word begins. */
5290 window_copy_cursor_previous_word(struct window_mode_entry
*wme
,
5291 const char *separators
, int already
)
5293 struct window_copy_mode_data
*data
= wme
->data
;
5294 struct window
*w
= wme
->wp
->window
;
5295 struct screen
*back_s
= data
->backing
;
5296 struct grid_reader gr
;
5297 u_int px
, py
, oldy
, hsize
;
5300 if (options_get_number(w
->options
, "mode-keys") == MODEKEY_EMACS
)
5306 hsize
= screen_hsize(back_s
);
5307 py
= hsize
+ data
->cy
- data
->oy
;
5310 grid_reader_start(&gr
, back_s
->grid
, px
, py
);
5311 grid_reader_cursor_previous_word(&gr
, separators
, already
, stop_at_eol
);
5312 grid_reader_get_cursor(&gr
, &px
, &py
);
5313 window_copy_acquire_cursor_up(wme
, hsize
, data
->oy
, oldy
, px
, py
);
5317 window_copy_scroll_up(struct window_mode_entry
*wme
, u_int ny
)
5319 struct window_pane
*wp
= wme
->wp
;
5320 struct window_copy_mode_data
*data
= wme
->data
;
5321 struct screen
*s
= &data
->screen
;
5322 struct screen_write_ctx ctx
;
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);
5334 screen_write_start_pane(&ctx
, wp
, NULL
);
5335 screen_write_cursormove(&ctx
, 0, 0, 0);
5336 screen_write_deleteline(&ctx
, ny
, 8);
5337 window_copy_write_lines(wme
, &ctx
, screen_size_y(s
) - ny
, ny
);
5338 window_copy_write_line(wme
, &ctx
, 0);
5339 if (screen_size_y(s
) > 1)
5340 window_copy_write_line(wme
, &ctx
, 1);
5341 if (screen_size_y(s
) > 3)
5342 window_copy_write_line(wme
, &ctx
, screen_size_y(s
) - 2);
5343 if (s
->sel
!= NULL
&& screen_size_y(s
) > ny
)
5344 window_copy_write_line(wme
, &ctx
, screen_size_y(s
) - ny
- 1);
5345 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
, 0);
5346 screen_write_stop(&ctx
);
5350 window_copy_scroll_down(struct window_mode_entry
*wme
, u_int ny
)
5352 struct window_pane
*wp
= wme
->wp
;
5353 struct window_copy_mode_data
*data
= wme
->data
;
5354 struct screen
*s
= &data
->screen
;
5355 struct screen_write_ctx ctx
;
5357 if (ny
> screen_hsize(data
->backing
))
5360 if (data
->oy
> screen_hsize(data
->backing
) - ny
)
5361 ny
= screen_hsize(data
->backing
) - data
->oy
;
5366 if (data
->searchmark
!= NULL
&& !data
->timeout
)
5367 window_copy_search_marks(wme
, NULL
, data
->searchregex
, 1);
5368 window_copy_update_selection(wme
, 0, 0);
5370 screen_write_start_pane(&ctx
, wp
, NULL
);
5371 screen_write_cursormove(&ctx
, 0, 0, 0);
5372 screen_write_insertline(&ctx
, ny
, 8);
5373 window_copy_write_lines(wme
, &ctx
, 0, ny
);
5374 if (s
->sel
!= NULL
&& screen_size_y(s
) > ny
)
5375 window_copy_write_line(wme
, &ctx
, ny
);
5376 else if (ny
== 1) /* nuke position */
5377 window_copy_write_line(wme
, &ctx
, 1);
5378 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
, 0);
5379 screen_write_stop(&ctx
);
5383 window_copy_rectangle_set(struct window_mode_entry
*wme
, int rectflag
)
5385 struct window_copy_mode_data
*data
= wme
->data
;
5388 data
->rectflag
= rectflag
;
5390 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5391 px
= window_copy_find_length(wme
, py
);
5393 window_copy_update_cursor(wme
, px
, data
->cy
);
5395 window_copy_update_selection(wme
, 1, 0);
5396 window_copy_redraw_screen(wme
);
5400 window_copy_move_mouse(struct mouse_event
*m
)
5402 struct window_pane
*wp
;
5403 struct window_mode_entry
*wme
;
5406 wp
= cmd_mouse_pane(m
, NULL
, NULL
);
5409 wme
= TAILQ_FIRST(&wp
->modes
);
5412 if (wme
->mode
!= &window_copy_mode
&& wme
->mode
!= &window_view_mode
)
5415 if (cmd_mouse_at(wp
, m
, &x
, &y
, 0) != 0)
5418 window_copy_update_cursor(wme
, x
, y
);
5422 window_copy_start_drag(struct client
*c
, struct mouse_event
*m
)
5424 struct window_pane
*wp
;
5425 struct window_mode_entry
*wme
;
5426 struct window_copy_mode_data
*data
;
5432 wp
= cmd_mouse_pane(m
, NULL
, NULL
);
5435 wme
= TAILQ_FIRST(&wp
->modes
);
5438 if (wme
->mode
!= &window_copy_mode
&& wme
->mode
!= &window_view_mode
)
5441 if (cmd_mouse_at(wp
, m
, &x
, &y
, 1) != 0)
5444 c
->tty
.mouse_drag_update
= window_copy_drag_update
;
5445 c
->tty
.mouse_drag_release
= window_copy_drag_release
;
5448 yg
= screen_hsize(data
->backing
) + y
- data
->oy
;
5449 if (x
< data
->selrx
|| x
> data
->endselrx
|| yg
!= data
->selry
)
5450 data
->selflag
= SEL_CHAR
;
5451 switch (data
->selflag
) {
5453 if (data
->separators
!= NULL
) {
5454 window_copy_update_cursor(wme
, x
, y
);
5455 window_copy_cursor_previous_word_pos(wme
,
5456 data
->separators
, &x
, &y
);
5457 y
-= screen_hsize(data
->backing
) - data
->oy
;
5459 window_copy_update_cursor(wme
, x
, y
);
5462 window_copy_update_cursor(wme
, 0, y
);
5465 window_copy_update_cursor(wme
, x
, y
);
5466 window_copy_start_selection(wme
);
5470 window_copy_redraw_screen(wme
);
5471 window_copy_drag_update(c
, m
);
5475 window_copy_drag_update(struct client
*c
, struct mouse_event
*m
)
5477 struct window_pane
*wp
;
5478 struct window_mode_entry
*wme
;
5479 struct window_copy_mode_data
*data
;
5480 u_int x
, y
, old_cx
, old_cy
;
5481 struct timeval tv
= {
5482 .tv_usec
= WINDOW_COPY_DRAG_REPEAT_TIME
5488 wp
= cmd_mouse_pane(m
, NULL
, NULL
);
5491 wme
= TAILQ_FIRST(&wp
->modes
);
5494 if (wme
->mode
!= &window_copy_mode
&& wme
->mode
!= &window_view_mode
)
5498 evtimer_del(&data
->dragtimer
);
5500 if (cmd_mouse_at(wp
, m
, &x
, &y
, 0) != 0)
5505 window_copy_update_cursor(wme
, x
, y
);
5506 if (window_copy_update_selection(wme
, 1, 0))
5507 window_copy_redraw_selection(wme
, old_cy
);
5508 if (old_cy
!= data
->cy
|| old_cx
== data
->cx
) {
5510 evtimer_add(&data
->dragtimer
, &tv
);
5511 window_copy_cursor_up(wme
, 1);
5512 } else if (y
== screen_size_y(&data
->screen
) - 1) {
5513 evtimer_add(&data
->dragtimer
, &tv
);
5514 window_copy_cursor_down(wme
, 1);
5520 window_copy_drag_release(struct client
*c
, struct mouse_event
*m
)
5522 struct window_pane
*wp
;
5523 struct window_mode_entry
*wme
;
5524 struct window_copy_mode_data
*data
;
5529 wp
= cmd_mouse_pane(m
, NULL
, NULL
);
5532 wme
= TAILQ_FIRST(&wp
->modes
);
5535 if (wme
->mode
!= &window_copy_mode
&& wme
->mode
!= &window_view_mode
)
5539 evtimer_del(&data
->dragtimer
);
5543 window_copy_jump_to_mark(struct window_mode_entry
*wme
)
5545 struct window_copy_mode_data
*data
= wme
->data
;
5549 tmy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
5550 data
->cx
= data
->mx
;
5551 if (data
->my
< screen_hsize(data
->backing
)) {
5553 data
->oy
= screen_hsize(data
->backing
) - data
->my
;
5555 data
->cy
= data
->my
- screen_hsize(data
->backing
);
5561 window_copy_update_selection(wme
, 0, 0);
5562 window_copy_redraw_screen(wme
);
5565 /* Scroll up if the cursor went off the visible screen. */
5567 window_copy_acquire_cursor_up(struct window_mode_entry
*wme
, u_int hsize
,
5568 u_int oy
, u_int oldy
, u_int px
, u_int py
)
5570 u_int cy
, yy
, ny
, nd
;
5583 window_copy_cursor_up(wme
, 1);
5586 window_copy_update_cursor(wme
, px
, cy
);
5587 if (window_copy_update_selection(wme
, 1, 0))
5588 window_copy_redraw_lines(wme
, cy
, nd
);
5591 /* Scroll down if the cursor went off the visible screen. */
5593 window_copy_acquire_cursor_down(struct window_mode_entry
*wme
, u_int hsize
,
5594 u_int sy
, u_int oy
, u_int oldy
, u_int px
, u_int py
, int no_reset
)
5596 u_int cy
, yy
, ny
, nd
;
5598 cy
= py
- hsize
+ oy
;
5609 window_copy_cursor_down(wme
, 1);
5613 window_copy_update_cursor(wme
, px
, yy
);
5615 window_copy_update_cursor(wme
, px
, cy
);
5616 if (window_copy_update_selection(wme
, 1, no_reset
))
5617 window_copy_redraw_lines(wme
, oldy
, nd
);