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