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