4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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>
26 struct screen
*window_copy_init(struct window_pane
*);
27 void window_copy_free(struct window_pane
*);
28 void window_copy_resize(struct window_pane
*, u_int
, u_int
);
29 void window_copy_key(struct window_pane
*, struct session
*, int);
30 int window_copy_key_input(struct window_pane
*, int);
31 int window_copy_key_numeric_prefix(struct window_pane
*, int);
32 void window_copy_mouse(
33 struct window_pane
*, struct session
*, struct mouse_event
*);
35 void window_copy_redraw_lines(struct window_pane
*, u_int
, u_int
);
36 void window_copy_redraw_screen(struct window_pane
*);
37 void window_copy_write_line(
38 struct window_pane
*, struct screen_write_ctx
*, u_int
);
39 void window_copy_write_lines(
40 struct window_pane
*, struct screen_write_ctx
*, u_int
, u_int
);
42 void window_copy_scroll_to(struct window_pane
*, u_int
, u_int
);
43 int window_copy_search_compare(
44 struct grid
*, u_int
, u_int
, struct grid
*, u_int
);
45 int window_copy_search_lr(
46 struct grid
*, struct grid
*, u_int
*, u_int
, u_int
, u_int
);
47 int window_copy_search_rl(
48 struct grid
*, struct grid
*, u_int
*, u_int
, u_int
, u_int
);
49 void window_copy_search_up(struct window_pane
*, const char *);
50 void window_copy_search_down(struct window_pane
*, const char *);
51 void window_copy_goto_line(struct window_pane
*, const char *);
52 void window_copy_update_cursor(struct window_pane
*, u_int
, u_int
);
53 void window_copy_start_selection(struct window_pane
*);
54 int window_copy_update_selection(struct window_pane
*);
55 void window_copy_copy_selection(struct window_pane
*, int);
56 void window_copy_clear_selection(struct window_pane
*);
57 void window_copy_copy_line(
58 struct window_pane
*, char **, size_t *, u_int
, u_int
, u_int
);
59 int window_copy_in_set(struct window_pane
*, u_int
, u_int
, const char *);
60 u_int
window_copy_find_length(struct window_pane
*, u_int
);
61 void window_copy_cursor_start_of_line(struct window_pane
*);
62 void window_copy_cursor_back_to_indentation(struct window_pane
*);
63 void window_copy_cursor_end_of_line(struct window_pane
*);
64 void window_copy_cursor_left(struct window_pane
*);
65 void window_copy_cursor_right(struct window_pane
*);
66 void window_copy_cursor_up(struct window_pane
*, int);
67 void window_copy_cursor_down(struct window_pane
*, int);
68 void window_copy_cursor_jump(struct window_pane
*);
69 void window_copy_cursor_jump_back(struct window_pane
*);
70 void window_copy_cursor_jump_to(struct window_pane
*);
71 void window_copy_cursor_jump_to_back(struct window_pane
*);
72 void window_copy_cursor_next_word(struct window_pane
*, const char *);
73 void window_copy_cursor_next_word_end(struct window_pane
*, const char *);
74 void window_copy_cursor_previous_word(struct window_pane
*, const char *);
75 void window_copy_scroll_up(struct window_pane
*, u_int
);
76 void window_copy_scroll_down(struct window_pane
*, u_int
);
77 void window_copy_rectangle_toggle(struct window_pane
*);
79 const struct window_mode window_copy_mode
= {
88 enum window_copy_input_type
{
90 WINDOW_COPY_NUMERICPREFIX
,
92 WINDOW_COPY_SEARCHDOWN
,
93 WINDOW_COPY_JUMPFORWARD
,
95 WINDOW_COPY_JUMPTOFORWARD
,
96 WINDOW_COPY_JUMPTOBACK
,
101 * Copy-mode's visible screen (the "screen" field) is filled from one of
102 * two sources: the original contents of the pane (used when we
103 * actually enter via the "copy-mode" command, to copy the contents of
104 * the current pane), or else a series of lines containing the output
105 * from an output-writing tmux command (such as any of the "show-*" or
106 * "list-*" commands).
108 * In either case, the full content of the copy-mode grid is pointed at
109 * by the "backing" field, and is copied into "screen" as needed (that
110 * is, when scrolling occurs). When copy-mode is backed by a pane,
111 * backing points directly at that pane's screen structure (&wp->base);
112 * when backed by a list of output-lines from a command, it points at
113 * a newly-allocated screen structure (which is deallocated when the
116 struct window_copy_mode_data
{
117 struct screen screen
;
119 struct screen
*backing
;
120 int backing_written
; /* backing display has started */
122 struct mode_key_data mdata
;
129 u_int rectflag
; /* are we in rectangle copy mode? */
134 u_int lastcx
; /* position in last line with content */
135 u_int lastsx
; /* size of last line with content */
137 enum window_copy_input_type inputtype
;
138 const char *inputprompt
;
143 enum window_copy_input_type searchtype
;
146 enum window_copy_input_type jumptype
;
151 window_copy_init(struct window_pane
*wp
)
153 struct window_copy_mode_data
*data
;
157 wp
->modedata
= data
= xmalloc(sizeof *data
);
165 data
->backing_written
= 0;
169 data
->inputtype
= WINDOW_COPY_OFF
;
170 data
->inputprompt
= NULL
;
171 data
->inputstr
= xstrdup("");
172 data
->numprefix
= -1;
174 data
->searchtype
= WINDOW_COPY_OFF
;
175 data
->searchstr
= NULL
;
178 bufferevent_disable(wp
->event
, EV_READ
|EV_WRITE
);
180 data
->jumptype
= WINDOW_COPY_OFF
;
181 data
->jumpchar
= '\0';
184 screen_init(s
, screen_size_x(&wp
->base
), screen_size_y(&wp
->base
), 0);
185 if (options_get_number(&wp
->window
->options
, "mode-mouse"))
186 s
->mode
|= MODE_MOUSE_STANDARD
;
188 keys
= options_get_number(&wp
->window
->options
, "mode-keys");
189 if (keys
== MODEKEY_EMACS
)
190 mode_key_init(&data
->mdata
, &mode_key_tree_emacs_copy
);
192 mode_key_init(&data
->mdata
, &mode_key_tree_vi_copy
);
194 data
->backing
= NULL
;
200 window_copy_init_from_pane(struct window_pane
*wp
)
202 struct window_copy_mode_data
*data
= wp
->modedata
;
203 struct screen
*s
= &data
->screen
;
204 struct screen_write_ctx ctx
;
207 if (wp
->mode
!= &window_copy_mode
)
208 fatalx("not in copy mode");
210 data
->backing
= &wp
->base
;
211 data
->cx
= data
->backing
->cx
;
212 data
->cy
= data
->backing
->cy
;
217 screen_write_start(&ctx
, NULL
, s
);
218 for (i
= 0; i
< screen_size_y(s
); i
++)
219 window_copy_write_line(wp
, &ctx
, i
);
220 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
);
221 screen_write_stop(&ctx
);
225 window_copy_init_for_output(struct window_pane
*wp
)
227 struct window_copy_mode_data
*data
= wp
->modedata
;
229 data
->backing
= xmalloc(sizeof *data
->backing
);
230 screen_init(data
->backing
, screen_size_x(&wp
->base
),
231 screen_size_y(&wp
->base
), UINT_MAX
);
232 data
->backing
->mode
&= ~MODE_WRAP
;
236 window_copy_free(struct window_pane
*wp
)
238 struct window_copy_mode_data
*data
= wp
->modedata
;
241 bufferevent_enable(wp
->event
, EV_READ
|EV_WRITE
);
243 if (data
->searchstr
!= NULL
)
244 xfree(data
->searchstr
);
245 xfree(data
->inputstr
);
247 if (data
->backing
!= &wp
->base
) {
248 screen_free(data
->backing
);
249 xfree(data
->backing
);
251 screen_free(&data
->screen
);
257 window_copy_add(struct window_pane
*wp
, const char *fmt
, ...)
262 window_copy_vadd(wp
, fmt
, ap
);
267 window_copy_vadd(struct window_pane
*wp
, const char *fmt
, va_list ap
)
269 struct window_copy_mode_data
*data
= wp
->modedata
;
270 struct screen
*backing
= data
->backing
;
271 struct screen_write_ctx back_ctx
, ctx
;
276 if (backing
== &wp
->base
)
279 utf8flag
= options_get_number(&wp
->window
->options
, "utf8");
280 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
282 old_hsize
= screen_hsize(data
->backing
);
283 screen_write_start(&back_ctx
, NULL
, backing
);
284 if (data
->backing_written
) {
286 * On the second or later line, do a CRLF before writing
287 * (so it's on a new line).
289 screen_write_carriagereturn(&back_ctx
);
290 screen_write_linefeed(&back_ctx
, 0);
292 data
->backing_written
= 1;
293 screen_write_vnputs(&back_ctx
, 0, &gc
, utf8flag
, fmt
, ap
);
294 screen_write_stop(&back_ctx
);
296 data
->oy
+= screen_hsize(data
->backing
) - old_hsize
;
298 screen_write_start(&ctx
, wp
, &data
->screen
);
301 * If the history has changed, draw the top line.
302 * (If there's any history at all, it has changed.)
304 if (screen_hsize(data
->backing
))
305 window_copy_redraw_lines(wp
, 0, 1);
307 /* Write the line, if it's visible. */
308 if (backing
->cy
+ data
->oy
< screen_size_y(backing
))
309 window_copy_redraw_lines(wp
, backing
->cy
, 1);
311 screen_write_stop(&ctx
);
315 window_copy_pageup(struct window_pane
*wp
)
317 struct window_copy_mode_data
*data
= wp
->modedata
;
318 struct screen
*s
= &data
->screen
;
322 if (screen_size_y(s
) > 2)
323 n
= screen_size_y(s
) - 2;
324 if (data
->oy
+ n
> screen_hsize(data
->backing
))
325 data
->oy
= screen_hsize(data
->backing
);
328 window_copy_update_selection(wp
);
329 window_copy_redraw_screen(wp
);
333 window_copy_resize(struct window_pane
*wp
, u_int sx
, u_int sy
)
335 struct window_copy_mode_data
*data
= wp
->modedata
;
336 struct screen
*s
= &data
->screen
;
337 struct screen_write_ctx ctx
;
339 screen_resize(s
, sx
, sy
);
340 if (data
->backing
!= &wp
->base
)
341 screen_resize(data
->backing
, sx
, sy
);
343 if (data
->cy
> sy
- 1)
347 if (data
->oy
> screen_hsize(data
->backing
))
348 data
->oy
= screen_hsize(data
->backing
);
350 window_copy_clear_selection(wp
);
352 screen_write_start(&ctx
, NULL
, s
);
353 window_copy_write_lines(wp
, &ctx
, 0, screen_size_y(s
) - 1);
354 screen_write_stop(&ctx
);
356 window_copy_redraw_screen(wp
);
360 window_copy_key(struct window_pane
*wp
, struct session
*sess
, int key
)
362 const char *word_separators
;
363 struct window_copy_mode_data
*data
= wp
->modedata
;
364 struct screen
*s
= &data
->screen
;
367 enum mode_key_cmd cmd
;
369 np
= data
->numprefix
;
373 if (data
->inputtype
== WINDOW_COPY_JUMPFORWARD
||
374 data
->inputtype
== WINDOW_COPY_JUMPBACK
||
375 data
->inputtype
== WINDOW_COPY_JUMPTOFORWARD
||
376 data
->inputtype
== WINDOW_COPY_JUMPTOBACK
) {
377 /* Ignore keys with modifiers. */
378 if ((key
& KEYC_MASK_MOD
) == 0) {
379 data
->jumpchar
= key
;
380 if (data
->inputtype
== WINDOW_COPY_JUMPFORWARD
) {
381 for (; np
!= 0; np
--)
382 window_copy_cursor_jump(wp
);
383 } else if (data
->inputtype
== WINDOW_COPY_JUMPBACK
) {
384 for (; np
!= 0; np
--)
385 window_copy_cursor_jump_back(wp
);
386 } else if (data
->inputtype
== WINDOW_COPY_JUMPTOFORWARD
) {
387 for (; np
!= 0; np
--)
388 window_copy_cursor_jump_to(wp
);
389 } else if (data
->inputtype
== WINDOW_COPY_JUMPTOBACK
) {
390 for (; np
!= 0; np
--)
391 window_copy_cursor_jump_to_back(wp
);
394 data
->jumptype
= data
->inputtype
;
395 data
->inputtype
= WINDOW_COPY_OFF
;
396 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
398 } else if (data
->inputtype
== WINDOW_COPY_NUMERICPREFIX
) {
399 if (window_copy_key_numeric_prefix(wp
, key
) == 0)
401 data
->inputtype
= WINDOW_COPY_OFF
;
402 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
403 } else if (data
->inputtype
!= WINDOW_COPY_OFF
) {
404 if (window_copy_key_input(wp
, key
) != 0)
409 cmd
= mode_key_lookup(&data
->mdata
, key
);
411 case MODEKEYCOPY_CANCEL
:
412 window_pane_reset_mode(wp
);
414 case MODEKEYCOPY_LEFT
:
415 for (; np
!= 0; np
--)
416 window_copy_cursor_left(wp
);
418 case MODEKEYCOPY_RIGHT
:
419 for (; np
!= 0; np
--)
420 window_copy_cursor_right(wp
);
423 for (; np
!= 0; np
--)
424 window_copy_cursor_up(wp
, 0);
426 case MODEKEYCOPY_DOWN
:
427 for (; np
!= 0; np
--)
428 window_copy_cursor_down(wp
, 0);
430 case MODEKEYCOPY_SCROLLUP
:
431 for (; np
!= 0; np
--)
432 window_copy_cursor_up(wp
, 1);
434 case MODEKEYCOPY_SCROLLDOWN
:
435 for (; np
!= 0; np
--)
436 window_copy_cursor_down(wp
, 1);
438 case MODEKEYCOPY_PREVIOUSPAGE
:
439 for (; np
!= 0; np
--)
440 window_copy_pageup(wp
);
442 case MODEKEYCOPY_NEXTPAGE
:
444 if (screen_size_y(s
) > 2)
445 n
= screen_size_y(s
) - 2;
446 for (; np
!= 0; np
--) {
452 window_copy_update_selection(wp
);
453 window_copy_redraw_screen(wp
);
455 case MODEKEYCOPY_HALFPAGEUP
:
456 n
= screen_size_y(s
) / 2;
457 for (; np
!= 0; np
--) {
458 if (data
->oy
+ n
> screen_hsize(data
->backing
))
459 data
->oy
= screen_hsize(data
->backing
);
463 window_copy_update_selection(wp
);
464 window_copy_redraw_screen(wp
);
466 case MODEKEYCOPY_HALFPAGEDOWN
:
467 n
= screen_size_y(s
) / 2;
468 for (; np
!= 0; np
--) {
474 window_copy_update_selection(wp
);
475 window_copy_redraw_screen(wp
);
477 case MODEKEYCOPY_TOPLINE
:
480 window_copy_update_selection(wp
);
481 window_copy_redraw_screen(wp
);
483 case MODEKEYCOPY_MIDDLELINE
:
485 data
->cy
= (screen_size_y(s
) - 1) / 2;
486 window_copy_update_selection(wp
);
487 window_copy_redraw_screen(wp
);
489 case MODEKEYCOPY_BOTTOMLINE
:
491 data
->cy
= screen_size_y(s
) - 1;
492 window_copy_update_selection(wp
);
493 window_copy_redraw_screen(wp
);
495 case MODEKEYCOPY_HISTORYTOP
:
498 data
->oy
= screen_hsize(data
->backing
);
499 window_copy_update_selection(wp
);
500 window_copy_redraw_screen(wp
);
502 case MODEKEYCOPY_HISTORYBOTTOM
:
504 data
->cy
= screen_size_y(s
) - 1;
506 window_copy_update_selection(wp
);
507 window_copy_redraw_screen(wp
);
509 case MODEKEYCOPY_STARTSELECTION
:
510 window_copy_start_selection(wp
);
511 window_copy_redraw_screen(wp
);
513 case MODEKEYCOPY_COPYLINE
:
514 case MODEKEYCOPY_SELECTLINE
:
515 window_copy_cursor_start_of_line(wp
);
517 case MODEKEYCOPY_COPYENDOFLINE
:
518 window_copy_start_selection(wp
);
520 window_copy_cursor_down(wp
, 0);
521 window_copy_cursor_end_of_line(wp
);
522 window_copy_redraw_screen(wp
);
524 /* If a copy command then copy the selection and exit. */
526 (cmd
== MODEKEYCOPY_COPYLINE
||
527 cmd
== MODEKEYCOPY_COPYENDOFLINE
)) {
528 window_copy_copy_selection(wp
, -1);
529 window_pane_reset_mode(wp
);
533 case MODEKEYCOPY_CLEARSELECTION
:
534 window_copy_clear_selection(wp
);
535 window_copy_redraw_screen(wp
);
537 case MODEKEYCOPY_COPYSELECTION
:
539 window_copy_copy_selection(wp
, data
->numprefix
);
540 window_pane_reset_mode(wp
);
544 case MODEKEYCOPY_STARTOFLINE
:
545 window_copy_cursor_start_of_line(wp
);
547 case MODEKEYCOPY_BACKTOINDENTATION
:
548 window_copy_cursor_back_to_indentation(wp
);
550 case MODEKEYCOPY_ENDOFLINE
:
551 window_copy_cursor_end_of_line(wp
);
553 case MODEKEYCOPY_NEXTSPACE
:
554 for (; np
!= 0; np
--)
555 window_copy_cursor_next_word(wp
, " ");
557 case MODEKEYCOPY_NEXTSPACEEND
:
558 for (; np
!= 0; np
--)
559 window_copy_cursor_next_word_end(wp
, " ");
561 case MODEKEYCOPY_NEXTWORD
:
563 options_get_string(&sess
->options
, "word-separators");
564 for (; np
!= 0; np
--)
565 window_copy_cursor_next_word(wp
, word_separators
);
567 case MODEKEYCOPY_NEXTWORDEND
:
569 options_get_string(&sess
->options
, "word-separators");
570 for (; np
!= 0; np
--)
571 window_copy_cursor_next_word_end(wp
, word_separators
);
573 case MODEKEYCOPY_PREVIOUSSPACE
:
574 for (; np
!= 0; np
--)
575 window_copy_cursor_previous_word(wp
, " ");
577 case MODEKEYCOPY_PREVIOUSWORD
:
579 options_get_string(&sess
->options
, "word-separators");
580 for (; np
!= 0; np
--)
581 window_copy_cursor_previous_word(wp
, word_separators
);
583 case MODEKEYCOPY_JUMP
:
584 data
->inputtype
= WINDOW_COPY_JUMPFORWARD
;
585 data
->inputprompt
= "Jump Forward";
586 *data
->inputstr
= '\0';
587 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
588 return; /* skip numprefix reset */
589 case MODEKEYCOPY_JUMPAGAIN
:
590 if (data
->jumptype
== WINDOW_COPY_JUMPFORWARD
) {
591 for (; np
!= 0; np
--)
592 window_copy_cursor_jump(wp
);
593 } else if (data
->jumptype
== WINDOW_COPY_JUMPBACK
) {
594 for (; np
!= 0; np
--)
595 window_copy_cursor_jump_back(wp
);
596 } else if (data
->jumptype
== WINDOW_COPY_JUMPTOFORWARD
) {
597 for (; np
!= 0; np
--)
598 window_copy_cursor_jump_to(wp
);
599 } else if (data
->jumptype
== WINDOW_COPY_JUMPTOBACK
) {
600 for (; np
!= 0; np
--)
601 window_copy_cursor_jump_to_back(wp
);
604 case MODEKEYCOPY_JUMPREVERSE
:
605 if (data
->jumptype
== WINDOW_COPY_JUMPFORWARD
) {
606 for (; np
!= 0; np
--)
607 window_copy_cursor_jump_back(wp
);
608 } else if (data
->jumptype
== WINDOW_COPY_JUMPBACK
) {
609 for (; np
!= 0; np
--)
610 window_copy_cursor_jump(wp
);
611 } else if (data
->jumptype
== WINDOW_COPY_JUMPTOFORWARD
) {
612 for (; np
!= 0; np
--)
613 window_copy_cursor_jump_to_back(wp
);
614 } else if (data
->jumptype
== WINDOW_COPY_JUMPTOBACK
) {
615 for (; np
!= 0; np
--)
616 window_copy_cursor_jump_to(wp
);
619 case MODEKEYCOPY_JUMPBACK
:
620 data
->inputtype
= WINDOW_COPY_JUMPBACK
;
621 data
->inputprompt
= "Jump Back";
622 *data
->inputstr
= '\0';
623 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
624 return; /* skip numprefix reset */
625 case MODEKEYCOPY_JUMPTO
:
626 data
->inputtype
= WINDOW_COPY_JUMPTOFORWARD
;
627 data
->inputprompt
= "Jump To";
628 *data
->inputstr
= '\0';
629 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
630 return; /* skip numprefix reset */
631 case MODEKEYCOPY_JUMPTOBACK
:
632 data
->inputtype
= WINDOW_COPY_JUMPTOBACK
;
633 data
->inputprompt
= "Jump To Back";
634 *data
->inputstr
= '\0';
635 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
636 return; /* skip numprefix reset */
637 case MODEKEYCOPY_SEARCHUP
:
638 data
->inputtype
= WINDOW_COPY_SEARCHUP
;
639 data
->inputprompt
= "Search Up";
641 case MODEKEYCOPY_SEARCHDOWN
:
642 data
->inputtype
= WINDOW_COPY_SEARCHDOWN
;
643 data
->inputprompt
= "Search Down";
645 case MODEKEYCOPY_SEARCHAGAIN
:
646 case MODEKEYCOPY_SEARCHREVERSE
:
647 switch (data
->searchtype
) {
648 case WINDOW_COPY_OFF
:
649 case WINDOW_COPY_GOTOLINE
:
650 case WINDOW_COPY_JUMPFORWARD
:
651 case WINDOW_COPY_JUMPBACK
:
652 case WINDOW_COPY_JUMPTOFORWARD
:
653 case WINDOW_COPY_JUMPTOBACK
:
654 case WINDOW_COPY_NUMERICPREFIX
:
656 case WINDOW_COPY_SEARCHUP
:
657 if (cmd
== MODEKEYCOPY_SEARCHAGAIN
) {
658 for (; np
!= 0; np
--) {
659 window_copy_search_up(
660 wp
, data
->searchstr
);
663 for (; np
!= 0; np
--) {
664 window_copy_search_down(
665 wp
, data
->searchstr
);
669 case WINDOW_COPY_SEARCHDOWN
:
670 if (cmd
== MODEKEYCOPY_SEARCHAGAIN
) {
671 for (; np
!= 0; np
--) {
672 window_copy_search_down(
673 wp
, data
->searchstr
);
676 for (; np
!= 0; np
--) {
677 window_copy_search_up(
678 wp
, data
->searchstr
);
684 case MODEKEYCOPY_GOTOLINE
:
685 data
->inputtype
= WINDOW_COPY_GOTOLINE
;
686 data
->inputprompt
= "Goto Line";
687 *data
->inputstr
= '\0';
689 case MODEKEYCOPY_STARTNUMBERPREFIX
:
690 key
&= KEYC_MASK_KEY
;
691 if (key
>= '0' && key
<= '9') {
692 data
->inputtype
= WINDOW_COPY_NUMERICPREFIX
;
694 window_copy_key_numeric_prefix(wp
, key
);
698 case MODEKEYCOPY_RECTANGLETOGGLE
:
699 window_copy_rectangle_toggle(wp
);
705 data
->numprefix
= -1;
709 keys
= options_get_number(&wp
->window
->options
, "mode-keys");
710 if (keys
== MODEKEY_EMACS
)
711 mode_key_init(&data
->mdata
, &mode_key_tree_emacs_edit
);
713 mode_key_init(&data
->mdata
, &mode_key_tree_vi_edit
);
715 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
719 keys
= options_get_number(&wp
->window
->options
, "mode-keys");
720 if (keys
== MODEKEY_EMACS
)
721 mode_key_init(&data
->mdata
, &mode_key_tree_emacs_copy
);
723 mode_key_init(&data
->mdata
, &mode_key_tree_vi_copy
);
725 data
->inputtype
= WINDOW_COPY_OFF
;
726 data
->inputprompt
= NULL
;
728 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
732 window_copy_key_input(struct window_pane
*wp
, int key
)
734 struct window_copy_mode_data
*data
= wp
->modedata
;
735 struct screen
*s
= &data
->screen
;
739 switch (mode_key_lookup(&data
->mdata
, key
)) {
740 case MODEKEYEDIT_CANCEL
:
741 data
->numprefix
= -1;
743 case MODEKEYEDIT_BACKSPACE
:
744 inputlen
= strlen(data
->inputstr
);
746 data
->inputstr
[inputlen
- 1] = '\0';
748 case MODEKEYEDIT_DELETELINE
:
749 *data
->inputstr
= '\0';
751 case MODEKEYEDIT_ENTER
:
752 np
= data
->numprefix
;
756 switch (data
->inputtype
) {
757 case WINDOW_COPY_OFF
:
758 case WINDOW_COPY_JUMPFORWARD
:
759 case WINDOW_COPY_JUMPBACK
:
760 case WINDOW_COPY_JUMPTOFORWARD
:
761 case WINDOW_COPY_JUMPTOBACK
:
762 case WINDOW_COPY_NUMERICPREFIX
:
764 case WINDOW_COPY_SEARCHUP
:
765 for (; np
!= 0; np
--)
766 window_copy_search_up(wp
, data
->inputstr
);
767 data
->searchtype
= data
->inputtype
;
768 data
->searchstr
= xstrdup(data
->inputstr
);
770 case WINDOW_COPY_SEARCHDOWN
:
771 for (; np
!= 0; np
--)
772 window_copy_search_down(wp
, data
->inputstr
);
773 data
->searchtype
= data
->inputtype
;
774 data
->searchstr
= xstrdup(data
->inputstr
);
776 case WINDOW_COPY_GOTOLINE
:
777 window_copy_goto_line(wp
, data
->inputstr
);
778 *data
->inputstr
= '\0';
781 data
->numprefix
= -1;
784 if (key
< 32 || key
> 126)
786 inputlen
= strlen(data
->inputstr
) + 2;
788 data
->inputstr
= xrealloc(data
->inputstr
, 1, inputlen
);
789 data
->inputstr
[inputlen
- 2] = key
;
790 data
->inputstr
[inputlen
- 1] = '\0';
796 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
801 window_copy_key_numeric_prefix(struct window_pane
*wp
, int key
)
803 struct window_copy_mode_data
*data
= wp
->modedata
;
804 struct screen
*s
= &data
->screen
;
806 key
&= KEYC_MASK_KEY
;
807 if (key
< '0' || key
> '9')
810 if (data
->numprefix
>= 100) /* no more than three digits */
812 data
->numprefix
= data
->numprefix
* 10 + key
- '0';
814 window_copy_redraw_lines(wp
, screen_size_y(s
) - 1, 1);
821 struct window_pane
*wp
, struct session
*sess
, struct mouse_event
*m
)
823 struct window_copy_mode_data
*data
= wp
->modedata
;
824 struct screen
*s
= &data
->screen
;
827 if (m
->x
>= screen_size_x(s
))
829 if (m
->y
>= screen_size_y(s
))
832 /* If mouse wheel (buttons 4 and 5), scroll. */
833 if ((m
->b
& MOUSE_45
)) {
834 if ((m
->b
& MOUSE_BUTTON
) == MOUSE_1
) {
835 for (i
= 0; i
< 5; i
++)
836 window_copy_cursor_up(wp
, 0);
837 } else if ((m
->b
& MOUSE_BUTTON
) == MOUSE_2
) {
839 for (i
= 0; i
< 5; i
++)
840 window_copy_cursor_down(wp
, 0);
841 if (old_cy
== data
->cy
)
848 * If already reading motion, move the cursor while buttons are still
849 * pressed, or stop the selection on their release.
851 if (s
->mode
& MODE_MOUSE_BUTTON
) {
852 if ((m
->b
& MOUSE_BUTTON
) != MOUSE_UP
) {
853 window_copy_update_cursor(wp
, m
->x
, m
->y
);
854 if (window_copy_update_selection(wp
))
855 window_copy_redraw_screen(wp
);
861 /* Otherwise if other buttons pressed, start selection and motion. */
862 if ((m
->b
& MOUSE_BUTTON
) != MOUSE_UP
) {
863 s
->mode
&= ~MODE_MOUSE_STANDARD
;
864 s
->mode
|= MODE_MOUSE_BUTTON
;
866 window_copy_update_cursor(wp
, m
->x
, m
->y
);
867 window_copy_start_selection(wp
);
868 window_copy_redraw_screen(wp
);
874 s
->mode
&= ~MODE_MOUSE_BUTTON
;
875 s
->mode
|= MODE_MOUSE_STANDARD
;
877 window_copy_copy_selection(wp
, -1);
878 window_pane_reset_mode(wp
);
883 window_copy_scroll_to(struct window_pane
*wp
, u_int px
, u_int py
)
885 struct window_copy_mode_data
*data
= wp
->modedata
;
886 struct grid
*gd
= data
->backing
->grid
;
895 } else if (py
> gd
->hsize
+ gd
->sy
- gap
) {
897 data
->cy
= py
- gd
->hsize
;
899 offset
= py
+ gap
- gd
->sy
;
900 data
->cy
= py
- offset
;
902 data
->oy
= gd
->hsize
- offset
;
904 window_copy_update_selection(wp
);
905 window_copy_redraw_screen(wp
);
909 window_copy_search_compare(
910 struct grid
*gd
, u_int px
, u_int py
, struct grid
*sgd
, u_int spx
)
912 const struct grid_cell
*gc
, *sgc
;
913 const struct grid_utf8
*gu
, *sgu
;
915 gc
= grid_peek_cell(gd
, px
, py
);
916 sgc
= grid_peek_cell(sgd
, spx
, 0);
918 if ((gc
->flags
& GRID_FLAG_UTF8
) != (sgc
->flags
& GRID_FLAG_UTF8
))
921 if (gc
->flags
& GRID_FLAG_UTF8
) {
922 gu
= grid_peek_utf8(gd
, px
, py
);
923 sgu
= grid_peek_utf8(sgd
, spx
, 0);
924 if (grid_utf8_compare(gu
, sgu
))
927 if (gc
->data
== sgc
->data
)
934 window_copy_search_lr(struct grid
*gd
,
935 struct grid
*sgd
, u_int
*ppx
, u_int py
, u_int first
, u_int last
)
939 for (ax
= first
; ax
< last
; ax
++) {
940 if (ax
+ sgd
->sx
>= gd
->sx
)
942 for (bx
= 0; bx
< sgd
->sx
; bx
++) {
944 if (!window_copy_search_compare(gd
, px
, py
, sgd
, bx
))
956 window_copy_search_rl(struct grid
*gd
,
957 struct grid
*sgd
, u_int
*ppx
, u_int py
, u_int first
, u_int last
)
961 for (ax
= last
+ 1; ax
> first
; ax
--) {
962 if (gd
->sx
- (ax
- 1) < sgd
->sx
)
964 for (bx
= 0; bx
< sgd
->sx
; bx
++) {
966 if (!window_copy_search_compare(gd
, px
, py
, sgd
, bx
))
978 window_copy_search_up(struct window_pane
*wp
, const char *searchstr
)
980 struct window_copy_mode_data
*data
= wp
->modedata
;
981 struct screen
*s
= data
->backing
, ss
;
982 struct screen_write_ctx ctx
;
983 struct grid
*gd
= s
->grid
, *sgd
;
986 u_int i
, last
, fx
, fy
, px
;
987 int utf8flag
, n
, wrapped
;
989 if (*searchstr
== '\0')
991 utf8flag
= options_get_number(&wp
->window
->options
, "utf8");
992 searchlen
= screen_write_strlen(utf8flag
, "%s", searchstr
);
994 screen_init(&ss
, searchlen
, 1, 0);
995 screen_write_start(&ctx
, NULL
, &ss
);
996 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
997 screen_write_nputs(&ctx
, -1, &gc
, utf8flag
, "%s", searchstr
);
998 screen_write_stop(&ctx
);
1001 fy
= gd
->hsize
- data
->oy
+ data
->cy
;
1014 for (i
= fy
+ 1; i
> 0; i
--) {
1015 last
= screen_size_x(s
);
1018 n
= window_copy_search_rl(gd
, sgd
, &px
, i
- 1, 0, last
);
1020 window_copy_scroll_to(wp
, px
, i
- 1);
1024 if (!n
&& !wrapped
) {
1026 fy
= gd
->hsize
+ gd
->sy
- 1;
1035 window_copy_search_down(struct window_pane
*wp
, const char *searchstr
)
1037 struct window_copy_mode_data
*data
= wp
->modedata
;
1038 struct screen
*s
= data
->backing
, ss
;
1039 struct screen_write_ctx ctx
;
1040 struct grid
*gd
= s
->grid
, *sgd
;
1041 struct grid_cell gc
;
1043 u_int i
, first
, fx
, fy
, px
;
1044 int utf8flag
, n
, wrapped
;
1046 if (*searchstr
== '\0')
1048 utf8flag
= options_get_number(&wp
->window
->options
, "utf8");
1049 searchlen
= screen_write_strlen(utf8flag
, "%s", searchstr
);
1051 screen_init(&ss
, searchlen
, 1, 0);
1052 screen_write_start(&ctx
, NULL
, &ss
);
1053 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
1054 screen_write_nputs(&ctx
, -1, &gc
, utf8flag
, "%s", searchstr
);
1055 screen_write_stop(&ctx
);
1058 fy
= gd
->hsize
- data
->oy
+ data
->cy
;
1060 if (fx
== gd
->sx
- 1) {
1061 if (fy
== gd
->hsize
+ gd
->sy
)
1071 for (i
= fy
+ 1; i
< gd
->hsize
+ gd
->sy
; i
++) {
1075 n
= window_copy_search_lr(gd
, sgd
, &px
, i
- 1, first
, gd
->sx
);
1077 window_copy_scroll_to(wp
, px
, i
- 1);
1081 if (!n
&& !wrapped
) {
1092 window_copy_goto_line(struct window_pane
*wp
, const char *linestr
)
1094 struct window_copy_mode_data
*data
= wp
->modedata
;
1098 lineno
= strtonum(linestr
, 0, screen_hsize(data
->backing
), &errstr
);
1103 window_copy_update_selection(wp
);
1104 window_copy_redraw_screen(wp
);
1108 window_copy_write_line(
1109 struct window_pane
*wp
, struct screen_write_ctx
*ctx
, u_int py
)
1111 struct window_copy_mode_data
*data
= wp
->modedata
;
1112 struct screen
*s
= &data
->screen
;
1113 struct options
*oo
= &wp
->window
->options
;
1114 struct grid_cell gc
;
1116 size_t last
, xoff
= 0, size
= 0;
1118 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
1119 colour_set_fg(&gc
, options_get_number(oo
, "mode-fg"));
1120 colour_set_bg(&gc
, options_get_number(oo
, "mode-bg"));
1121 gc
.attr
|= options_get_number(oo
, "mode-attr");
1123 last
= screen_size_y(s
) - 1;
1125 size
= xsnprintf(hdr
, sizeof hdr
,
1126 "[%u/%u]", data
->oy
, screen_hsize(data
->backing
));
1127 if (size
> screen_size_x(s
))
1128 size
= screen_size_x(s
);
1129 screen_write_cursormove(ctx
, screen_size_x(s
) - size
, 0);
1130 screen_write_puts(ctx
, &gc
, "%s", hdr
);
1131 } else if (py
== last
&& data
->inputtype
!= WINDOW_COPY_OFF
) {
1132 if (data
->inputtype
== WINDOW_COPY_NUMERICPREFIX
) {
1133 xoff
= size
= xsnprintf(hdr
, sizeof hdr
,
1134 "Repeat: %u", data
->numprefix
);
1136 xoff
= size
= xsnprintf(hdr
, sizeof hdr
,
1137 "%s: %s", data
->inputprompt
, data
->inputstr
);
1139 screen_write_cursormove(ctx
, 0, last
);
1140 screen_write_puts(ctx
, &gc
, "%s", hdr
);
1144 screen_write_cursormove(ctx
, xoff
, py
);
1145 screen_write_copy(ctx
, data
->backing
, xoff
,
1146 (screen_hsize(data
->backing
) - data
->oy
) + py
,
1147 screen_size_x(s
) - size
, 1);
1149 if (py
== data
->cy
&& data
->cx
== screen_size_x(s
)) {
1150 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
1151 screen_write_cursormove(ctx
, screen_size_x(s
) - 1, py
);
1152 screen_write_putc(ctx
, &gc
, '$');
1157 window_copy_write_lines(
1158 struct window_pane
*wp
, struct screen_write_ctx
*ctx
, u_int py
, u_int ny
)
1162 for (yy
= py
; yy
< py
+ ny
; yy
++)
1163 window_copy_write_line(wp
, ctx
, py
);
1167 window_copy_redraw_lines(struct window_pane
*wp
, u_int py
, u_int ny
)
1169 struct window_copy_mode_data
*data
= wp
->modedata
;
1170 struct screen_write_ctx ctx
;
1173 screen_write_start(&ctx
, wp
, NULL
);
1174 for (i
= py
; i
< py
+ ny
; i
++)
1175 window_copy_write_line(wp
, &ctx
, i
);
1176 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
);
1177 screen_write_stop(&ctx
);
1181 window_copy_redraw_screen(struct window_pane
*wp
)
1183 struct window_copy_mode_data
*data
= wp
->modedata
;
1185 window_copy_redraw_lines(wp
, 0, screen_size_y(&data
->screen
));
1189 window_copy_update_cursor(struct window_pane
*wp
, u_int cx
, u_int cy
)
1191 struct window_copy_mode_data
*data
= wp
->modedata
;
1192 struct screen
*s
= &data
->screen
;
1193 struct screen_write_ctx ctx
;
1194 u_int old_cx
, old_cy
;
1196 old_cx
= data
->cx
; old_cy
= data
->cy
;
1197 data
->cx
= cx
; data
->cy
= cy
;
1198 if (old_cx
== screen_size_x(s
))
1199 window_copy_redraw_lines(wp
, old_cy
, 1);
1200 if (data
->cx
== screen_size_x(s
))
1201 window_copy_redraw_lines(wp
, data
->cy
, 1);
1203 screen_write_start(&ctx
, wp
, NULL
);
1204 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
);
1205 screen_write_stop(&ctx
);
1210 window_copy_start_selection(struct window_pane
*wp
)
1212 struct window_copy_mode_data
*data
= wp
->modedata
;
1213 struct screen
*s
= &data
->screen
;
1215 data
->selx
= data
->cx
;
1216 data
->sely
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1219 window_copy_update_selection(wp
);
1223 window_copy_update_selection(struct window_pane
*wp
)
1225 struct window_copy_mode_data
*data
= wp
->modedata
;
1226 struct screen
*s
= &data
->screen
;
1227 struct options
*oo
= &wp
->window
->options
;
1228 struct grid_cell gc
;
1229 u_int sx
, sy
, ty
, cy
;
1235 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
1236 colour_set_fg(&gc
, options_get_number(oo
, "mode-fg"));
1237 colour_set_bg(&gc
, options_get_number(oo
, "mode-bg"));
1238 gc
.attr
|= options_get_number(oo
, "mode-attr");
1240 /* Find top of screen. */
1241 ty
= screen_hsize(data
->backing
) - data
->oy
;
1243 /* Adjust the selection. */
1246 if (sy
< ty
) { /* above screen */
1247 if (!data
->rectflag
)
1250 } else if (sy
> ty
+ screen_size_y(s
) - 1) { /* below screen */
1251 if (!data
->rectflag
)
1252 sx
= screen_size_x(s
) - 1;
1253 sy
= screen_size_y(s
) - 1;
1256 sy
= screen_hsize(s
) + sy
;
1258 screen_set_selection(s
,
1259 sx
, sy
, data
->cx
, screen_hsize(s
) + data
->cy
, data
->rectflag
, &gc
);
1261 if (data
->rectflag
) {
1263 * Can't rely on the caller to redraw the right lines for
1264 * rectangle selection - find the highest line and the number
1265 * of lines, and redraw just past that in both directions
1269 window_copy_redraw_lines(wp
, sy
, cy
- sy
+ 1);
1271 window_copy_redraw_lines(wp
, cy
, sy
- cy
+ 1);
1278 window_copy_copy_selection(struct window_pane
*wp
, int idx
)
1280 struct window_copy_mode_data
*data
= wp
->modedata
;
1281 struct screen
*s
= &data
->screen
;
1284 u_int i
, xx
, yy
, sx
, sy
, ex
, ey
, limit
;
1285 u_int firstsx
, lastex
, restex
, restsx
;
1297 * The selection extends from selx,sely to (adjusted) cx,cy on
1301 /* Find start and end. */
1303 yy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1304 if (yy
< data
->sely
|| (yy
== data
->sely
&& xx
< data
->selx
)) {
1306 ex
= data
->selx
; ey
= data
->sely
;
1308 sx
= data
->selx
; sy
= data
->sely
;
1312 /* Trim ex to end of line. */
1313 xx
= window_copy_find_length(wp
, ey
);
1318 * Deal with rectangle-copy if necessary; four situations: start of
1319 * first line (firstsx), end of last line (lastex), start (restsx) and
1320 * end (restex) of all other lines.
1322 xx
= screen_size_x(s
);
1325 * Behave according to mode-keys. If it is emacs, copy like emacs,
1326 * keeping the top-left-most character, and dropping the
1327 * bottom-right-most, regardless of copy direction. If it is vi, also
1328 * keep bottom-right-most character.
1330 keys
= options_get_number(&wp
->window
->options
, "mode-keys");
1331 if (data
->rectflag
) {
1333 * Need to ignore the column with the cursor in it, which for
1334 * rectangular copy means knowing which side the cursor is on.
1336 if (data
->selx
< data
->cx
) {
1337 /* Selection start is on the left. */
1338 if (keys
== MODEKEY_EMACS
) {
1343 lastex
= data
->cx
+ 1;
1344 restex
= data
->cx
+ 1;
1346 firstsx
= data
->selx
;
1347 restsx
= data
->selx
;
1349 /* Cursor is on the left. */
1350 lastex
= data
->selx
+ 1;
1351 restex
= data
->selx
+ 1;
1356 if (keys
== MODEKEY_EMACS
)
1365 /* Copy the lines. */
1367 window_copy_copy_line(wp
, &buf
, &off
, sy
, firstsx
, lastex
);
1369 window_copy_copy_line(wp
, &buf
, &off
, sy
, firstsx
, restex
);
1371 for (i
= sy
+ 1; i
< ey
; i
++) {
1372 window_copy_copy_line(
1373 wp
, &buf
, &off
, i
, restsx
, restex
);
1376 window_copy_copy_line(wp
, &buf
, &off
, ey
, restsx
, lastex
);
1379 /* Don't bother if no data. */
1384 off
--; /* remove final \n */
1386 if (options_get_number(&global_options
, "set-clipboard"))
1387 screen_write_setselection(&wp
->ictx
.ctx
, buf
, off
);
1389 /* Add the buffer to the stack. */
1391 limit
= options_get_number(&global_options
, "buffer-limit");
1392 paste_add(&global_buffers
, buf
, off
, limit
);
1394 paste_replace(&global_buffers
, idx
, buf
, off
);
1398 window_copy_copy_line(struct window_pane
*wp
,
1399 char **buf
, size_t *off
, u_int sy
, u_int sx
, u_int ex
)
1401 struct window_copy_mode_data
*data
= wp
->modedata
;
1402 struct grid
*gd
= data
->backing
->grid
;
1403 const struct grid_cell
*gc
;
1404 const struct grid_utf8
*gu
;
1405 struct grid_line
*gl
;
1406 u_int i
, xx
, wrapped
= 0;
1413 * Work out if the line was wrapped at the screen edge and all of it is
1416 gl
= &gd
->linedata
[sy
];
1417 if (gl
->flags
& GRID_LINE_WRAPPED
&& gl
->cellsize
<= gd
->sx
)
1420 /* If the line was wrapped, don't strip spaces (use the full length). */
1424 xx
= window_copy_find_length(wp
, sy
);
1431 for (i
= sx
; i
< ex
; i
++) {
1432 gc
= grid_peek_cell(gd
, i
, sy
);
1433 if (gc
->flags
& GRID_FLAG_PADDING
)
1435 if (!(gc
->flags
& GRID_FLAG_UTF8
)) {
1436 *buf
= xrealloc(*buf
, 1, (*off
) + 1);
1437 (*buf
)[(*off
)++] = gc
->data
;
1439 gu
= grid_peek_utf8(gd
, i
, sy
);
1440 size
= grid_utf8_size(gu
);
1441 *buf
= xrealloc(*buf
, 1, (*off
) + size
);
1442 *off
+= grid_utf8_copy(gu
, *buf
+ *off
, size
);
1447 /* Only add a newline if the line wasn't wrapped. */
1448 if (!wrapped
|| ex
!= xx
) {
1449 *buf
= xrealloc(*buf
, 1, (*off
) + 1);
1450 (*buf
)[(*off
)++] = '\n';
1455 window_copy_clear_selection(struct window_pane
*wp
)
1457 struct window_copy_mode_data
*data
= wp
->modedata
;
1460 screen_clear_selection(&data
->screen
);
1462 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1463 px
= window_copy_find_length(wp
, py
);
1465 window_copy_update_cursor(wp
, px
, data
->cy
);
1469 window_copy_in_set(struct window_pane
*wp
, u_int px
, u_int py
, const char *set
)
1471 struct window_copy_mode_data
*data
= wp
->modedata
;
1472 const struct grid_cell
*gc
;
1474 gc
= grid_peek_cell(data
->backing
->grid
, px
, py
);
1475 if (gc
->flags
& (GRID_FLAG_PADDING
|GRID_FLAG_UTF8
))
1477 if (gc
->data
== 0x00 || gc
->data
== 0x7f)
1479 return (strchr(set
, gc
->data
) != NULL
);
1483 window_copy_find_length(struct window_pane
*wp
, u_int py
)
1485 struct window_copy_mode_data
*data
= wp
->modedata
;
1486 struct screen
*s
= data
->backing
;
1487 const struct grid_cell
*gc
;
1491 * If the pane has been resized, its grid can contain old overlong
1492 * lines. grid_peek_cell does not allow accessing cells beyond the
1493 * width of the grid, and screen_write_copy treats them as spaces, so
1494 * ignore them here too.
1496 px
= s
->grid
->linedata
[py
].cellsize
;
1497 if (px
> screen_size_x(s
))
1498 px
= screen_size_x(s
);
1500 gc
= grid_peek_cell(s
->grid
, px
- 1, py
);
1501 if (gc
->flags
& GRID_FLAG_UTF8
)
1503 if (gc
->data
!= ' ')
1511 window_copy_cursor_start_of_line(struct window_pane
*wp
)
1513 struct window_copy_mode_data
*data
= wp
->modedata
;
1514 struct screen
*back_s
= data
->backing
;
1515 struct grid
*gd
= back_s
->grid
;
1518 if (data
->cx
== 0) {
1519 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1520 while (py
> 0 && gd
->linedata
[py
-1].flags
& GRID_LINE_WRAPPED
) {
1521 window_copy_cursor_up(wp
, 0);
1522 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1525 window_copy_update_cursor(wp
, 0, data
->cy
);
1526 if (window_copy_update_selection(wp
))
1527 window_copy_redraw_lines(wp
, data
->cy
, 1);
1531 window_copy_cursor_back_to_indentation(struct window_pane
*wp
)
1533 struct window_copy_mode_data
*data
= wp
->modedata
;
1535 const struct grid_cell
*gc
;
1538 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1539 xx
= window_copy_find_length(wp
, py
);
1542 gc
= grid_peek_cell(data
->backing
->grid
, px
, py
);
1543 if (gc
->flags
& GRID_FLAG_UTF8
)
1545 if (gc
->data
!= ' ')
1550 window_copy_update_cursor(wp
, px
, data
->cy
);
1551 if (window_copy_update_selection(wp
))
1552 window_copy_redraw_lines(wp
, data
->cy
, 1);
1556 window_copy_cursor_end_of_line(struct window_pane
*wp
)
1558 struct window_copy_mode_data
*data
= wp
->modedata
;
1559 struct screen
*back_s
= data
->backing
;
1560 struct grid
*gd
= back_s
->grid
;
1563 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1564 px
= window_copy_find_length(wp
, py
);
1566 if (data
->cx
== px
) {
1567 if (data
->screen
.sel
.flag
&& data
->rectflag
)
1568 px
= screen_size_x(back_s
);
1569 if (gd
->linedata
[py
].flags
& GRID_LINE_WRAPPED
) {
1570 while (py
< gd
->sy
+ gd
->hsize
&&
1571 gd
->linedata
[py
].flags
& GRID_LINE_WRAPPED
) {
1572 window_copy_cursor_down(wp
, 0);
1573 py
= screen_hsize(back_s
)
1574 + data
->cy
- data
->oy
;
1576 px
= window_copy_find_length(wp
, py
);
1579 window_copy_update_cursor(wp
, px
, data
->cy
);
1581 if (window_copy_update_selection(wp
))
1582 window_copy_redraw_lines(wp
, data
->cy
, 1);
1586 window_copy_cursor_left(struct window_pane
*wp
)
1588 struct window_copy_mode_data
*data
= wp
->modedata
;
1590 if (data
->cx
== 0) {
1591 window_copy_cursor_up(wp
, 0);
1592 window_copy_cursor_end_of_line(wp
);
1594 window_copy_update_cursor(wp
, data
->cx
- 1, data
->cy
);
1595 if (window_copy_update_selection(wp
))
1596 window_copy_redraw_lines(wp
, data
->cy
, 1);
1601 window_copy_cursor_right(struct window_pane
*wp
)
1603 struct window_copy_mode_data
*data
= wp
->modedata
;
1606 if (data
->screen
.sel
.flag
&& data
->rectflag
)
1607 px
= screen_size_x(&data
->screen
);
1609 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1610 px
= window_copy_find_length(wp
, py
);
1613 if (data
->cx
>= px
) {
1614 window_copy_cursor_start_of_line(wp
);
1615 window_copy_cursor_down(wp
, 0);
1617 window_copy_update_cursor(wp
, data
->cx
+ 1, data
->cy
);
1618 if (window_copy_update_selection(wp
))
1619 window_copy_redraw_lines(wp
, data
->cy
, 1);
1624 window_copy_cursor_up(struct window_pane
*wp
, int scroll_only
)
1626 struct window_copy_mode_data
*data
= wp
->modedata
;
1627 struct screen
*s
= &data
->screen
;
1628 u_int ox
, oy
, px
, py
;
1630 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1631 ox
= window_copy_find_length(wp
, oy
);
1633 data
->lastcx
= data
->cx
;
1637 data
->cx
= data
->lastcx
;
1638 if (scroll_only
|| data
->cy
== 0) {
1639 window_copy_scroll_down(wp
, 1);
1641 if (data
->cy
== screen_size_y(s
) - 1)
1642 window_copy_redraw_lines(wp
, data
->cy
, 1);
1644 window_copy_redraw_lines(wp
, data
->cy
, 2);
1647 window_copy_update_cursor(wp
, data
->cx
, data
->cy
- 1);
1648 if (window_copy_update_selection(wp
)) {
1649 if (data
->cy
== screen_size_y(s
) - 1)
1650 window_copy_redraw_lines(wp
, data
->cy
, 1);
1652 window_copy_redraw_lines(wp
, data
->cy
, 2);
1656 if (!data
->screen
.sel
.flag
|| !data
->rectflag
) {
1657 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1658 px
= window_copy_find_length(wp
, py
);
1659 if ((data
->cx
>= data
->lastsx
&& data
->cx
!= px
) ||
1661 window_copy_cursor_end_of_line(wp
);
1666 window_copy_cursor_down(struct window_pane
*wp
, int scroll_only
)
1668 struct window_copy_mode_data
*data
= wp
->modedata
;
1669 struct screen
*s
= &data
->screen
;
1670 u_int ox
, oy
, px
, py
;
1672 oy
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1673 ox
= window_copy_find_length(wp
, oy
);
1675 data
->lastcx
= data
->cx
;
1679 data
->cx
= data
->lastcx
;
1680 if (scroll_only
|| data
->cy
== screen_size_y(s
) - 1) {
1681 window_copy_scroll_up(wp
, 1);
1682 if (scroll_only
&& data
->cy
> 0)
1683 window_copy_redraw_lines(wp
, data
->cy
- 1, 2);
1685 window_copy_update_cursor(wp
, data
->cx
, data
->cy
+ 1);
1686 if (window_copy_update_selection(wp
))
1687 window_copy_redraw_lines(wp
, data
->cy
- 1, 2);
1690 if (!data
->screen
.sel
.flag
|| !data
->rectflag
) {
1691 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1692 px
= window_copy_find_length(wp
, py
);
1693 if ((data
->cx
>= data
->lastsx
&& data
->cx
!= px
) ||
1695 window_copy_cursor_end_of_line(wp
);
1700 window_copy_cursor_jump(struct window_pane
*wp
)
1702 struct window_copy_mode_data
*data
= wp
->modedata
;
1703 struct screen
*back_s
= data
->backing
;
1704 const struct grid_cell
*gc
;
1708 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1709 xx
= window_copy_find_length(wp
, py
);
1712 gc
= grid_peek_cell(back_s
->grid
, px
, py
);
1713 if ((gc
->flags
& (GRID_FLAG_PADDING
|GRID_FLAG_UTF8
)) == 0
1714 && gc
->data
== data
->jumpchar
) {
1716 window_copy_update_cursor(wp
, px
, data
->cy
);
1717 if (window_copy_update_selection(wp
))
1718 window_copy_redraw_lines(wp
, data
->cy
, 1);
1726 window_copy_cursor_jump_back(struct window_pane
*wp
)
1728 struct window_copy_mode_data
*data
= wp
->modedata
;
1729 struct screen
*back_s
= data
->backing
;
1730 const struct grid_cell
*gc
;
1734 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1740 gc
= grid_peek_cell(back_s
->grid
, px
, py
);
1741 if ((gc
->flags
& (GRID_FLAG_PADDING
|GRID_FLAG_UTF8
)) == 0
1742 && gc
->data
== data
->jumpchar
) {
1744 window_copy_update_cursor(wp
, px
, data
->cy
);
1745 if (window_copy_update_selection(wp
))
1746 window_copy_redraw_lines(wp
, data
->cy
, 1);
1756 window_copy_cursor_jump_to(struct window_pane
*wp
)
1758 struct window_copy_mode_data
*data
= wp
->modedata
;
1759 struct screen
*back_s
= data
->backing
;
1760 const struct grid_cell
*gc
;
1764 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1765 xx
= window_copy_find_length(wp
, py
);
1768 gc
= grid_peek_cell(back_s
->grid
, px
, py
);
1769 if ((gc
->flags
& (GRID_FLAG_PADDING
|GRID_FLAG_UTF8
)) == 0
1770 && gc
->data
== data
->jumpchar
) {
1772 window_copy_update_cursor(wp
, px
- 1, data
->cy
);
1773 if (window_copy_update_selection(wp
))
1774 window_copy_redraw_lines(wp
, data
->cy
, 1);
1782 window_copy_cursor_jump_to_back(struct window_pane
*wp
)
1784 struct window_copy_mode_data
*data
= wp
->modedata
;
1785 struct screen
*back_s
= data
->backing
;
1786 const struct grid_cell
*gc
;
1790 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1796 gc
= grid_peek_cell(back_s
->grid
, px
, py
);
1797 if ((gc
->flags
& (GRID_FLAG_PADDING
|GRID_FLAG_UTF8
)) == 0
1798 && gc
->data
== data
->jumpchar
) {
1800 window_copy_update_cursor(wp
, px
+ 1, data
->cy
);
1801 if (window_copy_update_selection(wp
))
1802 window_copy_redraw_lines(wp
, data
->cy
, 1);
1812 window_copy_cursor_next_word(struct window_pane
*wp
, const char *separators
)
1814 struct window_copy_mode_data
*data
= wp
->modedata
;
1815 struct screen
*back_s
= data
->backing
;
1816 u_int px
, py
, xx
, yy
;
1820 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1821 xx
= window_copy_find_length(wp
, py
);
1822 yy
= screen_hsize(back_s
) + screen_size_y(back_s
) - 1;
1825 * First skip past any nonword characters and then any word characters.
1827 * expected is initially set to 0 for the former and then 1 for the
1832 window_copy_in_set(wp
, px
, py
, separators
) == expected
) {
1833 /* Move down if we're past the end of the line. */
1837 window_copy_cursor_down(wp
, 0);
1840 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1841 xx
= window_copy_find_length(wp
, py
);
1845 expected
= !expected
;
1846 } while (expected
== 1);
1848 window_copy_update_cursor(wp
, px
, data
->cy
);
1849 if (window_copy_update_selection(wp
))
1850 window_copy_redraw_lines(wp
, data
->cy
, 1);
1854 window_copy_cursor_next_word_end(struct window_pane
*wp
, const char *separators
)
1856 struct window_copy_mode_data
*data
= wp
->modedata
;
1857 struct screen
*back_s
= data
->backing
;
1858 u_int px
, py
, xx
, yy
;
1862 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1863 xx
= window_copy_find_length(wp
, py
);
1864 yy
= screen_hsize(back_s
) + screen_size_y(back_s
) - 1;
1867 * First skip past any word characters, then any nonword characters.
1869 * expected is initially set to 1 for the former and then 0 for the
1874 window_copy_in_set(wp
, px
, py
, separators
) == expected
) {
1875 /* Move down if we're past the end of the line. */
1879 window_copy_cursor_down(wp
, 0);
1882 py
= screen_hsize(back_s
) + data
->cy
- data
->oy
;
1883 xx
= window_copy_find_length(wp
, py
);
1887 expected
= !expected
;
1888 } while (expected
== 0);
1890 window_copy_update_cursor(wp
, px
, data
->cy
);
1891 if (window_copy_update_selection(wp
))
1892 window_copy_redraw_lines(wp
, data
->cy
, 1);
1895 /* Move to the previous place where a word begins. */
1897 window_copy_cursor_previous_word(struct window_pane
*wp
, const char *separators
)
1899 struct window_copy_mode_data
*data
= wp
->modedata
;
1903 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1905 /* Move back to the previous word character. */
1909 if (!window_copy_in_set(wp
, px
, py
, separators
))
1912 if (data
->cy
== 0 &&
1913 (screen_hsize(data
->backing
) == 0 ||
1914 data
->oy
>= screen_hsize(data
->backing
) - 1))
1916 window_copy_cursor_up(wp
, 0);
1918 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
1919 px
= window_copy_find_length(wp
, py
);
1923 /* Move back to the beginning of this word. */
1924 while (px
> 0 && !window_copy_in_set(wp
, px
- 1, py
, separators
))
1928 window_copy_update_cursor(wp
, px
, data
->cy
);
1929 if (window_copy_update_selection(wp
))
1930 window_copy_redraw_lines(wp
, data
->cy
, 1);
1934 window_copy_scroll_up(struct window_pane
*wp
, u_int ny
)
1936 struct window_copy_mode_data
*data
= wp
->modedata
;
1937 struct screen
*s
= &data
->screen
;
1938 struct screen_write_ctx ctx
;
1946 screen_write_start(&ctx
, wp
, NULL
);
1947 screen_write_cursormove(&ctx
, 0, 0);
1948 screen_write_deleteline(&ctx
, ny
);
1949 window_copy_write_lines(wp
, &ctx
, screen_size_y(s
) - ny
, ny
);
1950 window_copy_write_line(wp
, &ctx
, 0);
1951 if (screen_size_y(s
) > 1)
1952 window_copy_write_line(wp
, &ctx
, 1);
1953 if (screen_size_y(s
) > 3)
1954 window_copy_write_line(wp
, &ctx
, screen_size_y(s
) - 2);
1955 if (s
->sel
.flag
&& screen_size_y(s
) > ny
) {
1956 window_copy_update_selection(wp
);
1957 window_copy_write_line(wp
, &ctx
, screen_size_y(s
) - ny
- 1);
1959 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
);
1960 window_copy_update_selection(wp
);
1961 screen_write_stop(&ctx
);
1965 window_copy_scroll_down(struct window_pane
*wp
, u_int ny
)
1967 struct window_copy_mode_data
*data
= wp
->modedata
;
1968 struct screen
*s
= &data
->screen
;
1969 struct screen_write_ctx ctx
;
1971 if (ny
> screen_hsize(data
->backing
))
1974 if (data
->oy
> screen_hsize(data
->backing
) - ny
)
1975 ny
= screen_hsize(data
->backing
) - data
->oy
;
1980 screen_write_start(&ctx
, wp
, NULL
);
1981 screen_write_cursormove(&ctx
, 0, 0);
1982 screen_write_insertline(&ctx
, ny
);
1983 window_copy_write_lines(wp
, &ctx
, 0, ny
);
1984 if (s
->sel
.flag
&& screen_size_y(s
) > ny
) {
1985 window_copy_update_selection(wp
);
1986 window_copy_write_line(wp
, &ctx
, ny
);
1987 } else if (ny
== 1) /* nuke position */
1988 window_copy_write_line(wp
, &ctx
, 1);
1989 screen_write_cursormove(&ctx
, data
->cx
, data
->cy
);
1990 window_copy_update_selection(wp
);
1991 screen_write_stop(&ctx
);
1995 window_copy_rectangle_toggle(struct window_pane
*wp
)
1997 struct window_copy_mode_data
*data
= wp
->modedata
;
2000 data
->rectflag
= !data
->rectflag
;
2002 py
= screen_hsize(data
->backing
) + data
->cy
- data
->oy
;
2003 px
= window_copy_find_length(wp
, py
);
2005 window_copy_update_cursor(wp
, px
, data
->cy
);
2007 window_copy_update_selection(wp
);
2008 window_copy_redraw_screen(wp
);