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