Annotation of src/usr.bin/tmux/window-copy.c, Revision 1.112
1.112 ! nicm 1: /* $OpenBSD: window-copy.c,v 1.111 2014/06/19 07:37:59 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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.21 nicm 22: #include <stdlib.h>
1.1 nicm 23: #include <string.h>
24:
25: #include "tmux.h"
26:
27: struct screen *window_copy_init(struct window_pane *);
28: void window_copy_free(struct window_pane *);
29: void window_copy_resize(struct window_pane *, u_int, u_int);
1.56 nicm 30: void window_copy_key(struct window_pane *, struct session *, int);
1.21 nicm 31: int window_copy_key_input(struct window_pane *, int);
1.50 nicm 32: int window_copy_key_numeric_prefix(struct window_pane *, int);
1.1 nicm 33: void window_copy_mouse(
1.56 nicm 34: struct window_pane *, struct session *, struct mouse_event *);
1.1 nicm 35:
36: void window_copy_redraw_lines(struct window_pane *, u_int, u_int);
37: void window_copy_redraw_screen(struct window_pane *);
38: void window_copy_write_line(
1.35 nicm 39: struct window_pane *, struct screen_write_ctx *, u_int);
1.1 nicm 40: void window_copy_write_lines(
1.35 nicm 41: struct window_pane *, struct screen_write_ctx *, u_int, u_int);
1.1 nicm 42:
1.21 nicm 43: void window_copy_scroll_to(struct window_pane *, u_int, u_int);
44: int window_copy_search_compare(
1.97 nicm 45: struct grid *, u_int, u_int, struct grid *, u_int, int);
1.21 nicm 46: int window_copy_search_lr(
1.97 nicm 47: struct grid *, struct grid *, u_int *, u_int, u_int, u_int, int);
1.21 nicm 48: int window_copy_search_rl(
1.97 nicm 49: struct grid *, struct grid *, u_int *, u_int, u_int, u_int, int);
1.21 nicm 50: void window_copy_search_up(struct window_pane *, const char *);
51: void window_copy_search_down(struct window_pane *, const char *);
52: void window_copy_goto_line(struct window_pane *, const char *);
1.18 nicm 53: void window_copy_update_cursor(struct window_pane *, u_int, u_int);
1.1 nicm 54: void window_copy_start_selection(struct window_pane *);
1.96 nicm 55: int window_copy_update_selection(struct window_pane *, int);
1.89 nicm 56: void *window_copy_get_selection(struct window_pane *, size_t *);
1.108 nicm 57: void window_copy_copy_buffer(struct window_pane *, const char *, void *,
58: size_t);
59: void window_copy_copy_pipe(struct window_pane *, struct session *,
60: const char *, const char *);
61: void window_copy_copy_selection(struct window_pane *, const char *);
62: void window_copy_append_selection(struct window_pane *, const char *);
1.47 nicm 63: void window_copy_clear_selection(struct window_pane *);
1.109 nicm 64: void window_copy_copy_line(struct window_pane *, char **, size_t *, u_int,
65: u_int, u_int);
1.41 nicm 66: int window_copy_in_set(struct window_pane *, u_int, u_int, const char *);
1.1 nicm 67: u_int window_copy_find_length(struct window_pane *, u_int);
68: void window_copy_cursor_start_of_line(struct window_pane *);
1.6 nicm 69: void window_copy_cursor_back_to_indentation(struct window_pane *);
1.1 nicm 70: void window_copy_cursor_end_of_line(struct window_pane *);
1.95 nicm 71: void window_copy_other_end(struct window_pane *);
1.1 nicm 72: void window_copy_cursor_left(struct window_pane *);
73: void window_copy_cursor_right(struct window_pane *);
1.28 nicm 74: void window_copy_cursor_up(struct window_pane *, int);
75: void window_copy_cursor_down(struct window_pane *, int);
1.52 nicm 76: void window_copy_cursor_jump(struct window_pane *);
77: void window_copy_cursor_jump_back(struct window_pane *);
1.76 nicm 78: void window_copy_cursor_jump_to(struct window_pane *);
79: void window_copy_cursor_jump_to_back(struct window_pane *);
1.41 nicm 80: void window_copy_cursor_next_word(struct window_pane *, const char *);
81: void window_copy_cursor_next_word_end(struct window_pane *, const char *);
82: void window_copy_cursor_previous_word(struct window_pane *, const char *);
1.1 nicm 83: void window_copy_scroll_up(struct window_pane *, u_int);
84: void window_copy_scroll_down(struct window_pane *, u_int);
1.42 nicm 85: void window_copy_rectangle_toggle(struct window_pane *);
1.1 nicm 86:
87: const struct window_mode window_copy_mode = {
88: window_copy_init,
89: window_copy_free,
90: window_copy_resize,
91: window_copy_key,
92: window_copy_mouse,
93: NULL,
94: };
95:
1.21 nicm 96: enum window_copy_input_type {
97: WINDOW_COPY_OFF,
1.109 nicm 98: WINDOW_COPY_NAMEDBUFFER,
1.50 nicm 99: WINDOW_COPY_NUMERICPREFIX,
1.21 nicm 100: WINDOW_COPY_SEARCHUP,
101: WINDOW_COPY_SEARCHDOWN,
1.52 nicm 102: WINDOW_COPY_JUMPFORWARD,
103: WINDOW_COPY_JUMPBACK,
1.76 nicm 104: WINDOW_COPY_JUMPTOFORWARD,
105: WINDOW_COPY_JUMPTOBACK,
1.21 nicm 106: WINDOW_COPY_GOTOLINE,
107: };
108:
1.54 nicm 109: /*
110: * Copy-mode's visible screen (the "screen" field) is filled from one of
111: * two sources: the original contents of the pane (used when we
112: * actually enter via the "copy-mode" command, to copy the contents of
113: * the current pane), or else a series of lines containing the output
114: * from an output-writing tmux command (such as any of the "show-*" or
115: * "list-*" commands).
116: *
117: * In either case, the full content of the copy-mode grid is pointed at
118: * by the "backing" field, and is copied into "screen" as needed (that
119: * is, when scrolling occurs). When copy-mode is backed by a pane,
120: * backing points directly at that pane's screen structure (&wp->base);
121: * when backed by a list of output-lines from a command, it points at
122: * a newly-allocated screen structure (which is deallocated when the
123: * mode ends).
124: */
1.1 nicm 125: struct window_copy_mode_data {
126: struct screen screen;
127:
1.54 nicm 128: struct screen *backing;
129: int backing_written; /* backing display has started */
130:
1.21 nicm 131: struct mode_key_data mdata;
132:
133: u_int oy;
134:
135: u_int selx;
136: u_int sely;
1.1 nicm 137:
1.42 nicm 138: u_int rectflag; /* are we in rectangle copy mode? */
139:
1.21 nicm 140: u_int cx;
141: u_int cy;
1.1 nicm 142:
1.25 nicm 143: u_int lastcx; /* position in last line with content */
144: u_int lastsx; /* size of last line with content */
145:
1.21 nicm 146: enum window_copy_input_type inputtype;
147: const char *inputprompt;
1.76 nicm 148: char *inputstr;
1.1 nicm 149:
1.74 nicm 150: int numprefix;
1.50 nicm 151:
1.21 nicm 152: enum window_copy_input_type searchtype;
153: char *searchstr;
1.52 nicm 154:
155: enum window_copy_input_type jumptype;
156: char jumpchar;
1.1 nicm 157: };
158:
159: struct screen *
160: window_copy_init(struct window_pane *wp)
161: {
162: struct window_copy_mode_data *data;
163: struct screen *s;
1.10 nicm 164: int keys;
1.1 nicm 165:
166: wp->modedata = data = xmalloc(sizeof *data);
167: data->oy = 0;
1.54 nicm 168: data->cx = 0;
169: data->cy = 0;
1.1 nicm 170:
1.25 nicm 171: data->lastcx = 0;
172: data->lastsx = 0;
173:
1.54 nicm 174: data->backing_written = 0;
175:
1.42 nicm 176: data->rectflag = 0;
177:
1.21 nicm 178: data->inputtype = WINDOW_COPY_OFF;
179: data->inputprompt = NULL;
180: data->inputstr = xstrdup("");
1.74 nicm 181: data->numprefix = -1;
1.21 nicm 182:
183: data->searchtype = WINDOW_COPY_OFF;
184: data->searchstr = NULL;
185:
1.61 nicm 186: if (wp->fd != -1)
187: bufferevent_disable(wp->event, EV_READ|EV_WRITE);
1.46 nicm 188:
1.52 nicm 189: data->jumptype = WINDOW_COPY_OFF;
190: data->jumpchar = '\0';
191:
1.1 nicm 192: s = &data->screen;
193: screen_init(s, screen_size_x(&wp->base), screen_size_y(&wp->base), 0);
1.13 nicm 194: if (options_get_number(&wp->window->options, "mode-mouse"))
1.65 nicm 195: s->mode |= MODE_MOUSE_STANDARD;
1.1 nicm 196:
1.10 nicm 197: keys = options_get_number(&wp->window->options, "mode-keys");
198: if (keys == MODEKEY_EMACS)
1.12 nicm 199: mode_key_init(&data->mdata, &mode_key_tree_emacs_copy);
1.10 nicm 200: else
1.12 nicm 201: mode_key_init(&data->mdata, &mode_key_tree_vi_copy);
1.112 ! nicm 202: s->sel.modekeys = keys;
1.1 nicm 203:
1.54 nicm 204: data->backing = NULL;
205:
206: return (s);
207: }
208:
209: void
210: window_copy_init_from_pane(struct window_pane *wp)
211: {
212: struct window_copy_mode_data *data = wp->modedata;
213: struct screen *s = &data->screen;
214: struct screen_write_ctx ctx;
215: u_int i;
216:
217: if (wp->mode != &window_copy_mode)
218: fatalx("not in copy mode");
219:
220: data->backing = &wp->base;
221: data->cx = data->backing->cx;
222: data->cy = data->backing->cy;
223:
1.1 nicm 224: s->cx = data->cx;
225: s->cy = data->cy;
226:
227: screen_write_start(&ctx, NULL, s);
228: for (i = 0; i < screen_size_y(s); i++)
229: window_copy_write_line(wp, &ctx, i);
230: screen_write_cursormove(&ctx, data->cx, data->cy);
231: screen_write_stop(&ctx);
1.54 nicm 232: }
1.1 nicm 233:
1.54 nicm 234: void
235: window_copy_init_for_output(struct window_pane *wp)
236: {
237: struct window_copy_mode_data *data = wp->modedata;
238:
239: data->backing = xmalloc(sizeof *data->backing);
240: screen_init(data->backing, screen_size_x(&wp->base),
241: screen_size_y(&wp->base), UINT_MAX);
242: data->backing->mode &= ~MODE_WRAP;
1.1 nicm 243: }
244:
245: void
246: window_copy_free(struct window_pane *wp)
247: {
248: struct window_copy_mode_data *data = wp->modedata;
1.46 nicm 249:
1.61 nicm 250: if (wp->fd != -1)
251: bufferevent_enable(wp->event, EV_READ|EV_WRITE);
1.1 nicm 252:
1.81 nicm 253: free(data->searchstr);
254: free(data->inputstr);
1.21 nicm 255:
1.54 nicm 256: if (data->backing != &wp->base) {
257: screen_free(data->backing);
1.81 nicm 258: free(data->backing);
1.54 nicm 259: }
1.1 nicm 260: screen_free(&data->screen);
1.21 nicm 261:
1.81 nicm 262: free(data);
1.1 nicm 263: }
264:
265: void
1.54 nicm 266: window_copy_add(struct window_pane *wp, const char *fmt, ...)
267: {
268: va_list ap;
269:
270: va_start(ap, fmt);
271: window_copy_vadd(wp, fmt, ap);
272: va_end(ap);
273: }
274:
275: void
276: window_copy_vadd(struct window_pane *wp, const char *fmt, va_list ap)
277: {
278: struct window_copy_mode_data *data = wp->modedata;
279: struct screen *backing = data->backing;
280: struct screen_write_ctx back_ctx, ctx;
281: struct grid_cell gc;
282: int utf8flag;
283: u_int old_hsize;
284:
285: if (backing == &wp->base)
286: return;
287:
288: utf8flag = options_get_number(&wp->window->options, "utf8");
289: memcpy(&gc, &grid_default_cell, sizeof gc);
290:
291: old_hsize = screen_hsize(data->backing);
292: screen_write_start(&back_ctx, NULL, backing);
293: if (data->backing_written) {
294: /*
295: * On the second or later line, do a CRLF before writing
296: * (so it's on a new line).
297: */
298: screen_write_carriagereturn(&back_ctx);
299: screen_write_linefeed(&back_ctx, 0);
300: } else
301: data->backing_written = 1;
302: screen_write_vnputs(&back_ctx, 0, &gc, utf8flag, fmt, ap);
303: screen_write_stop(&back_ctx);
304:
305: data->oy += screen_hsize(data->backing) - old_hsize;
306:
307: screen_write_start(&ctx, wp, &data->screen);
308:
309: /*
310: * If the history has changed, draw the top line.
311: * (If there's any history at all, it has changed.)
312: */
313: if (screen_hsize(data->backing))
314: window_copy_redraw_lines(wp, 0, 1);
315:
316: /* Write the line, if it's visible. */
317: if (backing->cy + data->oy < screen_size_y(backing))
318: window_copy_redraw_lines(wp, backing->cy, 1);
319:
320: screen_write_stop(&ctx);
321: }
322:
323: void
1.1 nicm 324: window_copy_pageup(struct window_pane *wp)
325: {
326: struct window_copy_mode_data *data = wp->modedata;
327: struct screen *s = &data->screen;
1.19 nicm 328: u_int n;
1.1 nicm 329:
1.19 nicm 330: n = 1;
331: if (screen_size_y(s) > 2)
332: n = screen_size_y(s) - 2;
1.54 nicm 333: if (data->oy + n > screen_hsize(data->backing))
334: data->oy = screen_hsize(data->backing);
1.1 nicm 335: else
1.19 nicm 336: data->oy += n;
1.96 nicm 337: window_copy_update_selection(wp, 1);
1.1 nicm 338: window_copy_redraw_screen(wp);
339: }
340:
341: void
342: window_copy_resize(struct window_pane *wp, u_int sx, u_int sy)
343: {
344: struct window_copy_mode_data *data = wp->modedata;
345: struct screen *s = &data->screen;
346: struct screen_write_ctx ctx;
347:
1.87 nicm 348: screen_resize(s, sx, sy, 0);
1.54 nicm 349: if (data->backing != &wp->base)
1.87 nicm 350: screen_resize(data->backing, sx, sy, 0);
1.35 nicm 351:
1.18 nicm 352: if (data->cy > sy - 1)
353: data->cy = sy - 1;
354: if (data->cx > sx)
355: data->cx = sx;
1.63 nicm 356: if (data->oy > screen_hsize(data->backing))
357: data->oy = screen_hsize(data->backing);
1.18 nicm 358:
1.47 nicm 359: window_copy_clear_selection(wp);
1.18 nicm 360:
1.1 nicm 361: screen_write_start(&ctx, NULL, s);
362: window_copy_write_lines(wp, &ctx, 0, screen_size_y(s) - 1);
363: screen_write_stop(&ctx);
1.18 nicm 364:
1.17 nicm 365: window_copy_redraw_screen(wp);
1.1 nicm 366: }
367:
368: void
1.56 nicm 369: window_copy_key(struct window_pane *wp, struct session *sess, int key)
1.1 nicm 370: {
1.48 nicm 371: const char *word_separators;
1.1 nicm 372: struct window_copy_mode_data *data = wp->modedata;
373: struct screen *s = &data->screen;
1.74 nicm 374: u_int n;
375: int np, keys;
1.43 nicm 376: enum mode_key_cmd cmd;
1.89 nicm 377: const char *arg;
1.21 nicm 378:
1.50 nicm 379: np = data->numprefix;
1.74 nicm 380: if (np <= 0)
1.50 nicm 381: np = 1;
382:
1.67 nicm 383: if (data->inputtype == WINDOW_COPY_JUMPFORWARD ||
1.76 nicm 384: data->inputtype == WINDOW_COPY_JUMPBACK ||
385: data->inputtype == WINDOW_COPY_JUMPTOFORWARD ||
386: data->inputtype == WINDOW_COPY_JUMPTOBACK) {
1.52 nicm 387: /* Ignore keys with modifiers. */
1.59 nicm 388: if ((key & KEYC_MASK_MOD) == 0) {
1.52 nicm 389: data->jumpchar = key;
390: if (data->inputtype == WINDOW_COPY_JUMPFORWARD) {
391: for (; np != 0; np--)
392: window_copy_cursor_jump(wp);
1.76 nicm 393: } else if (data->inputtype == WINDOW_COPY_JUMPBACK) {
1.52 nicm 394: for (; np != 0; np--)
395: window_copy_cursor_jump_back(wp);
1.76 nicm 396: } else if (data->inputtype == WINDOW_COPY_JUMPTOFORWARD) {
397: for (; np != 0; np--)
398: window_copy_cursor_jump_to(wp);
399: } else if (data->inputtype == WINDOW_COPY_JUMPTOBACK) {
400: for (; np != 0; np--)
401: window_copy_cursor_jump_to_back(wp);
1.52 nicm 402: }
403: }
404: data->jumptype = data->inputtype;
405: data->inputtype = WINDOW_COPY_OFF;
406: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
407: return;
1.67 nicm 408: } else if (data->inputtype == WINDOW_COPY_NUMERICPREFIX) {
1.50 nicm 409: if (window_copy_key_numeric_prefix(wp, key) == 0)
410: return;
411: data->inputtype = WINDOW_COPY_OFF;
412: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
413: } else if (data->inputtype != WINDOW_COPY_OFF) {
1.21 nicm 414: if (window_copy_key_input(wp, key) != 0)
415: goto input_off;
416: return;
417: }
1.1 nicm 418:
1.89 nicm 419: cmd = mode_key_lookup(&data->mdata, key, &arg);
1.43 nicm 420: switch (cmd) {
1.103 nicm 421: case MODEKEYCOPY_APPENDSELECTION:
422: if (sess != NULL) {
1.108 nicm 423: window_copy_append_selection(wp, NULL);
1.103 nicm 424: window_pane_reset_mode(wp);
425: return;
426: }
427: break;
1.11 nicm 428: case MODEKEYCOPY_CANCEL:
1.51 nicm 429: window_pane_reset_mode(wp);
430: return;
1.95 nicm 431: case MODEKEYCOPY_OTHEREND:
432: for (; np != 0; np--)
433: window_copy_other_end(wp);
434: break;
1.10 nicm 435: case MODEKEYCOPY_LEFT:
1.50 nicm 436: for (; np != 0; np--)
437: window_copy_cursor_left(wp);
438: break;
1.10 nicm 439: case MODEKEYCOPY_RIGHT:
1.50 nicm 440: for (; np != 0; np--)
441: window_copy_cursor_right(wp);
442: break;
1.10 nicm 443: case MODEKEYCOPY_UP:
1.50 nicm 444: for (; np != 0; np--)
445: window_copy_cursor_up(wp, 0);
446: break;
1.10 nicm 447: case MODEKEYCOPY_DOWN:
1.50 nicm 448: for (; np != 0; np--)
449: window_copy_cursor_down(wp, 0);
450: break;
1.28 nicm 451: case MODEKEYCOPY_SCROLLUP:
1.50 nicm 452: for (; np != 0; np--)
453: window_copy_cursor_up(wp, 1);
1.28 nicm 454: break;
455: case MODEKEYCOPY_SCROLLDOWN:
1.50 nicm 456: for (; np != 0; np--)
457: window_copy_cursor_down(wp, 1);
1.28 nicm 458: break;
1.10 nicm 459: case MODEKEYCOPY_PREVIOUSPAGE:
1.50 nicm 460: for (; np != 0; np--)
461: window_copy_pageup(wp);
1.1 nicm 462: break;
1.10 nicm 463: case MODEKEYCOPY_NEXTPAGE:
1.19 nicm 464: n = 1;
465: if (screen_size_y(s) > 2)
466: n = screen_size_y(s) - 2;
1.50 nicm 467: for (; np != 0; np--) {
468: if (data->oy < n)
469: data->oy = 0;
470: else
471: data->oy -= n;
472: }
1.96 nicm 473: window_copy_update_selection(wp, 1);
1.20 nicm 474: window_copy_redraw_screen(wp);
475: break;
476: case MODEKEYCOPY_HALFPAGEUP:
477: n = screen_size_y(s) / 2;
1.50 nicm 478: for (; np != 0; np--) {
1.54 nicm 479: if (data->oy + n > screen_hsize(data->backing))
480: data->oy = screen_hsize(data->backing);
1.50 nicm 481: else
482: data->oy += n;
483: }
1.96 nicm 484: window_copy_update_selection(wp, 1);
1.20 nicm 485: window_copy_redraw_screen(wp);
486: break;
487: case MODEKEYCOPY_HALFPAGEDOWN:
488: n = screen_size_y(s) / 2;
1.50 nicm 489: for (; np != 0; np--) {
490: if (data->oy < n)
491: data->oy = 0;
492: else
493: data->oy -= n;
494: }
1.96 nicm 495: window_copy_update_selection(wp, 1);
1.30 nicm 496: window_copy_redraw_screen(wp);
497: break;
498: case MODEKEYCOPY_TOPLINE:
499: data->cx = 0;
500: data->cy = 0;
1.96 nicm 501: window_copy_update_selection(wp, 1);
1.30 nicm 502: window_copy_redraw_screen(wp);
503: break;
504: case MODEKEYCOPY_MIDDLELINE:
505: data->cx = 0;
506: data->cy = (screen_size_y(s) - 1) / 2;
1.96 nicm 507: window_copy_update_selection(wp, 1);
1.30 nicm 508: window_copy_redraw_screen(wp);
509: break;
510: case MODEKEYCOPY_BOTTOMLINE:
511: data->cx = 0;
512: data->cy = screen_size_y(s) - 1;
1.96 nicm 513: window_copy_update_selection(wp, 1);
1.37 nicm 514: window_copy_redraw_screen(wp);
515: break;
516: case MODEKEYCOPY_HISTORYTOP:
517: data->cx = 0;
518: data->cy = 0;
1.54 nicm 519: data->oy = screen_hsize(data->backing);
1.96 nicm 520: window_copy_update_selection(wp, 1);
1.37 nicm 521: window_copy_redraw_screen(wp);
522: break;
523: case MODEKEYCOPY_HISTORYBOTTOM:
524: data->cx = 0;
525: data->cy = screen_size_y(s) - 1;
526: data->oy = 0;
1.96 nicm 527: window_copy_update_selection(wp, 1);
1.1 nicm 528: window_copy_redraw_screen(wp);
529: break;
1.10 nicm 530: case MODEKEYCOPY_STARTSELECTION:
1.35 nicm 531: window_copy_start_selection(wp);
1.7 nicm 532: window_copy_redraw_screen(wp);
1.71 nicm 533: break;
534: case MODEKEYCOPY_COPYLINE:
535: case MODEKEYCOPY_SELECTLINE:
536: window_copy_cursor_start_of_line(wp);
537: /* FALLTHROUGH */
538: case MODEKEYCOPY_COPYENDOFLINE:
539: window_copy_start_selection(wp);
540: for (; np > 1; np--)
541: window_copy_cursor_down(wp, 0);
542: window_copy_cursor_end_of_line(wp);
543: window_copy_redraw_screen(wp);
544:
545: /* If a copy command then copy the selection and exit. */
546: if (sess != NULL &&
547: (cmd == MODEKEYCOPY_COPYLINE ||
548: cmd == MODEKEYCOPY_COPYENDOFLINE)) {
1.108 nicm 549: window_copy_copy_selection(wp, NULL);
1.71 nicm 550: window_pane_reset_mode(wp);
551: return;
552: }
1.1 nicm 553: break;
1.10 nicm 554: case MODEKEYCOPY_CLEARSELECTION:
1.47 nicm 555: window_copy_clear_selection(wp);
1.1 nicm 556: window_copy_redraw_screen(wp);
557: break;
1.89 nicm 558: case MODEKEYCOPY_COPYPIPE:
559: if (sess != NULL) {
1.108 nicm 560: window_copy_copy_pipe(wp, sess, NULL, arg);
1.89 nicm 561: window_pane_reset_mode(wp);
562: return;
563: }
564: break;
1.10 nicm 565: case MODEKEYCOPY_COPYSELECTION:
1.56 nicm 566: if (sess != NULL) {
1.108 nicm 567: window_copy_copy_selection(wp, NULL);
1.1 nicm 568: window_pane_reset_mode(wp);
1.51 nicm 569: return;
1.1 nicm 570: }
571: break;
1.10 nicm 572: case MODEKEYCOPY_STARTOFLINE:
1.1 nicm 573: window_copy_cursor_start_of_line(wp);
574: break;
1.10 nicm 575: case MODEKEYCOPY_BACKTOINDENTATION:
1.6 nicm 576: window_copy_cursor_back_to_indentation(wp);
577: break;
1.10 nicm 578: case MODEKEYCOPY_ENDOFLINE:
1.1 nicm 579: window_copy_cursor_end_of_line(wp);
580: break;
1.41 nicm 581: case MODEKEYCOPY_NEXTSPACE:
1.50 nicm 582: for (; np != 0; np--)
583: window_copy_cursor_next_word(wp, " ");
1.41 nicm 584: break;
585: case MODEKEYCOPY_NEXTSPACEEND:
1.50 nicm 586: for (; np != 0; np--)
587: window_copy_cursor_next_word_end(wp, " ");
1.41 nicm 588: break;
1.10 nicm 589: case MODEKEYCOPY_NEXTWORD:
1.48 nicm 590: word_separators =
1.75 nicm 591: options_get_string(&sess->options, "word-separators");
1.50 nicm 592: for (; np != 0; np--)
593: window_copy_cursor_next_word(wp, word_separators);
1.1 nicm 594: break;
1.40 nicm 595: case MODEKEYCOPY_NEXTWORDEND:
1.48 nicm 596: word_separators =
1.75 nicm 597: options_get_string(&sess->options, "word-separators");
1.50 nicm 598: for (; np != 0; np--)
599: window_copy_cursor_next_word_end(wp, word_separators);
1.41 nicm 600: break;
601: case MODEKEYCOPY_PREVIOUSSPACE:
1.50 nicm 602: for (; np != 0; np--)
603: window_copy_cursor_previous_word(wp, " ");
1.40 nicm 604: break;
1.10 nicm 605: case MODEKEYCOPY_PREVIOUSWORD:
1.48 nicm 606: word_separators =
1.75 nicm 607: options_get_string(&sess->options, "word-separators");
1.50 nicm 608: for (; np != 0; np--)
609: window_copy_cursor_previous_word(wp, word_separators);
1.1 nicm 610: break;
1.52 nicm 611: case MODEKEYCOPY_JUMP:
612: data->inputtype = WINDOW_COPY_JUMPFORWARD;
613: data->inputprompt = "Jump Forward";
614: *data->inputstr = '\0';
615: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
616: return; /* skip numprefix reset */
617: case MODEKEYCOPY_JUMPAGAIN:
618: if (data->jumptype == WINDOW_COPY_JUMPFORWARD) {
619: for (; np != 0; np--)
620: window_copy_cursor_jump(wp);
621: } else if (data->jumptype == WINDOW_COPY_JUMPBACK) {
622: for (; np != 0; np--)
623: window_copy_cursor_jump_back(wp);
1.76 nicm 624: } else if (data->jumptype == WINDOW_COPY_JUMPTOFORWARD) {
625: for (; np != 0; np--)
626: window_copy_cursor_jump_to(wp);
627: } else if (data->jumptype == WINDOW_COPY_JUMPTOBACK) {
628: for (; np != 0; np--)
629: window_copy_cursor_jump_to_back(wp);
1.52 nicm 630: }
631: break;
632: case MODEKEYCOPY_JUMPREVERSE:
633: if (data->jumptype == WINDOW_COPY_JUMPFORWARD) {
634: for (; np != 0; np--)
635: window_copy_cursor_jump_back(wp);
636: } else if (data->jumptype == WINDOW_COPY_JUMPBACK) {
637: for (; np != 0; np--)
638: window_copy_cursor_jump(wp);
1.76 nicm 639: } else if (data->jumptype == WINDOW_COPY_JUMPTOFORWARD) {
640: for (; np != 0; np--)
641: window_copy_cursor_jump_to_back(wp);
642: } else if (data->jumptype == WINDOW_COPY_JUMPTOBACK) {
643: for (; np != 0; np--)
644: window_copy_cursor_jump_to(wp);
1.52 nicm 645: }
646: break;
647: case MODEKEYCOPY_JUMPBACK:
648: data->inputtype = WINDOW_COPY_JUMPBACK;
649: data->inputprompt = "Jump Back";
650: *data->inputstr = '\0';
651: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
652: return; /* skip numprefix reset */
1.76 nicm 653: case MODEKEYCOPY_JUMPTO:
654: data->inputtype = WINDOW_COPY_JUMPTOFORWARD;
655: data->inputprompt = "Jump To";
656: *data->inputstr = '\0';
657: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
658: return; /* skip numprefix reset */
659: case MODEKEYCOPY_JUMPTOBACK:
660: data->inputtype = WINDOW_COPY_JUMPTOBACK;
661: data->inputprompt = "Jump To Back";
662: *data->inputstr = '\0';
663: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
664: return; /* skip numprefix reset */
1.21 nicm 665: case MODEKEYCOPY_SEARCHUP:
666: data->inputtype = WINDOW_COPY_SEARCHUP;
667: data->inputprompt = "Search Up";
668: goto input_on;
669: case MODEKEYCOPY_SEARCHDOWN:
670: data->inputtype = WINDOW_COPY_SEARCHDOWN;
671: data->inputprompt = "Search Down";
672: goto input_on;
673: case MODEKEYCOPY_SEARCHAGAIN:
1.43 nicm 674: case MODEKEYCOPY_SEARCHREVERSE:
1.21 nicm 675: switch (data->searchtype) {
676: case WINDOW_COPY_OFF:
677: case WINDOW_COPY_GOTOLINE:
1.52 nicm 678: case WINDOW_COPY_JUMPFORWARD:
679: case WINDOW_COPY_JUMPBACK:
1.76 nicm 680: case WINDOW_COPY_JUMPTOFORWARD:
681: case WINDOW_COPY_JUMPTOBACK:
1.109 nicm 682: case WINDOW_COPY_NAMEDBUFFER:
1.50 nicm 683: case WINDOW_COPY_NUMERICPREFIX:
1.21 nicm 684: break;
685: case WINDOW_COPY_SEARCHUP:
1.50 nicm 686: if (cmd == MODEKEYCOPY_SEARCHAGAIN) {
687: for (; np != 0; np--) {
688: window_copy_search_up(
689: wp, data->searchstr);
690: }
691: } else {
692: for (; np != 0; np--) {
693: window_copy_search_down(
694: wp, data->searchstr);
695: }
696: }
1.21 nicm 697: break;
698: case WINDOW_COPY_SEARCHDOWN:
1.50 nicm 699: if (cmd == MODEKEYCOPY_SEARCHAGAIN) {
700: for (; np != 0; np--) {
701: window_copy_search_down(
702: wp, data->searchstr);
703: }
704: } else {
705: for (; np != 0; np--) {
706: window_copy_search_up(
707: wp, data->searchstr);
708: }
709: }
1.21 nicm 710: break;
711: }
712: break;
713: case MODEKEYCOPY_GOTOLINE:
714: data->inputtype = WINDOW_COPY_GOTOLINE;
715: data->inputprompt = "Goto Line";
716: *data->inputstr = '\0';
717: goto input_on;
1.109 nicm 718: case MODEKEYCOPY_STARTNAMEDBUFFER:
719: data->inputtype = WINDOW_COPY_NAMEDBUFFER;
720: data->inputprompt = "Buffer";
721: *data->inputstr = '\0';
722: goto input_on;
1.50 nicm 723: case MODEKEYCOPY_STARTNUMBERPREFIX:
1.59 nicm 724: key &= KEYC_MASK_KEY;
1.50 nicm 725: if (key >= '0' && key <= '9') {
726: data->inputtype = WINDOW_COPY_NUMERICPREFIX;
727: data->numprefix = 0;
728: window_copy_key_numeric_prefix(wp, key);
729: return;
730: }
731: break;
1.42 nicm 732: case MODEKEYCOPY_RECTANGLETOGGLE:
733: window_copy_rectangle_toggle(wp);
1.50 nicm 734: break;
1.21 nicm 735: default:
736: break;
737: }
738:
1.74 nicm 739: data->numprefix = -1;
1.21 nicm 740: return;
741:
742: input_on:
743: keys = options_get_number(&wp->window->options, "mode-keys");
744: if (keys == MODEKEY_EMACS)
745: mode_key_init(&data->mdata, &mode_key_tree_emacs_edit);
746: else
747: mode_key_init(&data->mdata, &mode_key_tree_vi_edit);
748:
749: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
750: return;
751:
752: input_off:
753: keys = options_get_number(&wp->window->options, "mode-keys");
754: if (keys == MODEKEY_EMACS)
755: mode_key_init(&data->mdata, &mode_key_tree_emacs_copy);
756: else
757: mode_key_init(&data->mdata, &mode_key_tree_vi_copy);
758:
759: data->inputtype = WINDOW_COPY_OFF;
760: data->inputprompt = NULL;
761:
762: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
763: }
764:
765: int
766: window_copy_key_input(struct window_pane *wp, int key)
767: {
768: struct window_copy_mode_data *data = wp->modedata;
769: struct screen *s = &data->screen;
1.100 nicm 770: size_t inputlen, n;
1.74 nicm 771: int np;
1.100 nicm 772: struct paste_buffer *pb;
773: u_char ch;
1.21 nicm 774:
1.89 nicm 775: switch (mode_key_lookup(&data->mdata, key, NULL)) {
1.21 nicm 776: case MODEKEYEDIT_CANCEL:
1.74 nicm 777: data->numprefix = -1;
1.21 nicm 778: return (-1);
779: case MODEKEYEDIT_BACKSPACE:
780: inputlen = strlen(data->inputstr);
781: if (inputlen > 0)
782: data->inputstr[inputlen - 1] = '\0';
1.22 nicm 783: break;
784: case MODEKEYEDIT_DELETELINE:
785: *data->inputstr = '\0';
1.21 nicm 786: break;
1.100 nicm 787: case MODEKEYEDIT_PASTE:
1.107 nicm 788: if ((pb = paste_get_top()) == NULL)
1.100 nicm 789: break;
790: for (n = 0; n < pb->size; n++) {
791: ch = (u_char) pb->data[n];
792: if (ch < 32 || ch == 127)
793: break;
794: }
795: inputlen = strlen(data->inputstr);
796:
797: data->inputstr = xrealloc(data->inputstr, 1, inputlen + n + 1);
798: memcpy(data->inputstr + inputlen, pb->data, n);
799: data->inputstr[inputlen + n] = '\0';
800: break;
1.21 nicm 801: case MODEKEYEDIT_ENTER:
1.50 nicm 802: np = data->numprefix;
1.74 nicm 803: if (np <= 0)
1.50 nicm 804: np = 1;
805:
1.21 nicm 806: switch (data->inputtype) {
807: case WINDOW_COPY_OFF:
1.52 nicm 808: case WINDOW_COPY_JUMPFORWARD:
809: case WINDOW_COPY_JUMPBACK:
1.76 nicm 810: case WINDOW_COPY_JUMPTOFORWARD:
811: case WINDOW_COPY_JUMPTOBACK:
1.50 nicm 812: case WINDOW_COPY_NUMERICPREFIX:
1.21 nicm 813: break;
814: case WINDOW_COPY_SEARCHUP:
1.50 nicm 815: for (; np != 0; np--)
816: window_copy_search_up(wp, data->inputstr);
1.21 nicm 817: data->searchtype = data->inputtype;
818: data->searchstr = xstrdup(data->inputstr);
819: break;
820: case WINDOW_COPY_SEARCHDOWN:
1.50 nicm 821: for (; np != 0; np--)
822: window_copy_search_down(wp, data->inputstr);
1.21 nicm 823: data->searchtype = data->inputtype;
824: data->searchstr = xstrdup(data->inputstr);
825: break;
1.109 nicm 826: case WINDOW_COPY_NAMEDBUFFER:
827: window_copy_copy_selection(wp, data->inputstr);
828: *data->inputstr = '\0';
829: window_pane_reset_mode(wp);
830: return (0);
1.21 nicm 831: case WINDOW_COPY_GOTOLINE:
832: window_copy_goto_line(wp, data->inputstr);
833: *data->inputstr = '\0';
834: break;
835: }
1.74 nicm 836: data->numprefix = -1;
1.21 nicm 837: return (1);
838: case MODEKEY_OTHER:
839: if (key < 32 || key > 126)
840: break;
841: inputlen = strlen(data->inputstr) + 2;
1.35 nicm 842:
1.21 nicm 843: data->inputstr = xrealloc(data->inputstr, 1, inputlen);
844: data->inputstr[inputlen - 2] = key;
845: data->inputstr[inputlen - 1] = '\0';
846: break;
1.1 nicm 847: default:
848: break;
849: }
1.21 nicm 850:
851: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
852: return (0);
1.1 nicm 853: }
854:
1.50 nicm 855: int
856: window_copy_key_numeric_prefix(struct window_pane *wp, int key)
857: {
858: struct window_copy_mode_data *data = wp->modedata;
859: struct screen *s = &data->screen;
860:
1.59 nicm 861: key &= KEYC_MASK_KEY;
1.50 nicm 862: if (key < '0' || key > '9')
1.80 nicm 863: return (1);
1.50 nicm 864:
1.74 nicm 865: if (data->numprefix >= 100) /* no more than three digits */
1.80 nicm 866: return (0);
1.50 nicm 867: data->numprefix = data->numprefix * 10 + key - '0';
868:
869: window_copy_redraw_lines(wp, screen_size_y(s) - 1, 1);
1.80 nicm 870: return (0);
1.50 nicm 871: }
872:
1.1 nicm 873: void
1.29 nicm 874: window_copy_mouse(
1.68 nicm 875: struct window_pane *wp, struct session *sess, struct mouse_event *m)
1.1 nicm 876: {
877: struct window_copy_mode_data *data = wp->modedata;
878: struct screen *s = &data->screen;
1.79 nicm 879: u_int i;
1.57 nicm 880:
1.29 nicm 881: if (m->x >= screen_size_x(s))
1.1 nicm 882: return;
1.29 nicm 883: if (m->y >= screen_size_y(s))
1.1 nicm 884: return;
885:
1.57 nicm 886: /* If mouse wheel (buttons 4 and 5), scroll. */
1.84 nicm 887: if (m->event == MOUSE_EVENT_WHEEL) {
1.104 nicm 888: for (i = 0; i < m->scroll; i++) {
889: if (m->wheel == MOUSE_WHEEL_UP)
1.85 nicm 890: window_copy_cursor_up(wp, 1);
1.104 nicm 891: else {
1.85 nicm 892: window_copy_cursor_down(wp, 1);
1.104 nicm 893:
894: /*
895: * We reached the bottom, leave copy mode, but
896: * only if no selection is in progress.
897: */
898: if (data->oy == 0 && !s->sel.flag)
899: goto reset_mode;
900: }
1.57 nicm 901: }
902: return;
903: }
904:
905: /*
906: * If already reading motion, move the cursor while buttons are still
907: * pressed, or stop the selection on their release.
908: */
1.70 nicm 909: if (s->mode & MODE_MOUSE_BUTTON) {
1.84 nicm 910: if (~m->event & MOUSE_EVENT_UP) {
1.57 nicm 911: window_copy_update_cursor(wp, m->x, m->y);
1.96 nicm 912: if (window_copy_update_selection(wp, 1))
1.57 nicm 913: window_copy_redraw_screen(wp);
1.68 nicm 914: return;
1.57 nicm 915: }
1.68 nicm 916: goto reset_mode;
1.57 nicm 917: }
918:
1.65 nicm 919: /* Otherwise if other buttons pressed, start selection and motion. */
1.84 nicm 920: if (~m->event & MOUSE_EVENT_UP) {
1.65 nicm 921: s->mode &= ~MODE_MOUSE_STANDARD;
1.70 nicm 922: s->mode |= MODE_MOUSE_BUTTON;
1.57 nicm 923:
924: window_copy_update_cursor(wp, m->x, m->y);
925: window_copy_start_selection(wp);
1.35 nicm 926: window_copy_redraw_screen(wp);
1.68 nicm 927: }
928:
929: return;
930:
931: reset_mode:
1.70 nicm 932: s->mode &= ~MODE_MOUSE_BUTTON;
1.68 nicm 933: s->mode |= MODE_MOUSE_STANDARD;
934: if (sess != NULL) {
1.108 nicm 935: window_copy_copy_selection(wp, NULL);
1.68 nicm 936: window_pane_reset_mode(wp);
1.57 nicm 937: }
1.1 nicm 938: }
939:
940: void
1.21 nicm 941: window_copy_scroll_to(struct window_pane *wp, u_int px, u_int py)
942: {
943: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 944: struct grid *gd = data->backing->grid;
1.21 nicm 945: u_int offset, gap;
946:
947: data->cx = px;
948:
949: gap = gd->sy / 4;
950: if (py < gd->sy) {
951: offset = 0;
952: data->cy = py;
953: } else if (py > gd->hsize + gd->sy - gap) {
954: offset = gd->hsize;
955: data->cy = py - gd->hsize;
956: } else {
957: offset = py + gap - gd->sy;
958: data->cy = py - offset;
959: }
1.35 nicm 960: data->oy = gd->hsize - offset;
1.21 nicm 961:
1.96 nicm 962: window_copy_update_selection(wp, 1);
1.21 nicm 963: window_copy_redraw_screen(wp);
964: }
965:
966: int
967: window_copy_search_compare(
1.97 nicm 968: struct grid *gd, u_int px, u_int py, struct grid *sgd, u_int spx, int cis)
1.21 nicm 969: {
970: const struct grid_cell *gc, *sgc;
1.86 nicm 971: struct utf8_data ud, sud;
1.21 nicm 972:
973: gc = grid_peek_cell(gd, px, py);
1.86 nicm 974: grid_cell_get(gc, &ud);
1.21 nicm 975: sgc = grid_peek_cell(sgd, spx, 0);
1.86 nicm 976: grid_cell_get(sgc, &sud);
1.35 nicm 977:
1.86 nicm 978: if (ud.size != sud.size || ud.width != sud.width)
1.21 nicm 979: return (0);
1.97 nicm 980:
981: if (cis && ud.size == 1)
982: return (tolower(ud.data[0]) == sud.data[0]);
983:
1.86 nicm 984: return (memcmp(ud.data, sud.data, ud.size) == 0);
1.21 nicm 985: }
986:
987: int
988: window_copy_search_lr(struct grid *gd,
1.97 nicm 989: struct grid *sgd, u_int *ppx, u_int py, u_int first, u_int last, int cis)
1.21 nicm 990: {
991: u_int ax, bx, px;
1.97 nicm 992: int matched;
1.21 nicm 993:
994: for (ax = first; ax < last; ax++) {
995: if (ax + sgd->sx >= gd->sx)
996: break;
997: for (bx = 0; bx < sgd->sx; bx++) {
998: px = ax + bx;
1.97 nicm 999: matched = window_copy_search_compare(gd, px, py, sgd,
1000: bx, cis);
1001: if (!matched)
1.21 nicm 1002: break;
1003: }
1004: if (bx == sgd->sx) {
1005: *ppx = ax;
1006: return (1);
1007: }
1008: }
1009: return (0);
1010: }
1011:
1012: int
1013: window_copy_search_rl(struct grid *gd,
1.97 nicm 1014: struct grid *sgd, u_int *ppx, u_int py, u_int first, u_int last, int cis)
1.21 nicm 1015: {
1016: u_int ax, bx, px;
1.97 nicm 1017: int matched;
1.21 nicm 1018:
1019: for (ax = last + 1; ax > first; ax--) {
1.24 nicm 1020: if (gd->sx - (ax - 1) < sgd->sx)
1021: continue;
1.21 nicm 1022: for (bx = 0; bx < sgd->sx; bx++) {
1023: px = ax - 1 + bx;
1.97 nicm 1024: matched = window_copy_search_compare(gd, px, py, sgd,
1025: bx, cis);
1026: if (!matched)
1.21 nicm 1027: break;
1028: }
1029: if (bx == sgd->sx) {
1030: *ppx = ax - 1;
1031: return (1);
1032: }
1033: }
1034: return (0);
1035: }
1036:
1037: void
1038: window_copy_search_up(struct window_pane *wp, const char *searchstr)
1039: {
1040: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 1041: struct screen *s = data->backing, ss;
1.21 nicm 1042: struct screen_write_ctx ctx;
1043: struct grid *gd = s->grid, *sgd;
1044: struct grid_cell gc;
1045: size_t searchlen;
1046: u_int i, last, fx, fy, px;
1.97 nicm 1047: int utf8flag, n, wrapped, wrapflag, cis;
1048: const char *ptr;
1.21 nicm 1049:
1050: if (*searchstr == '\0')
1051: return;
1052: utf8flag = options_get_number(&wp->window->options, "utf8");
1.78 nicm 1053: wrapflag = options_get_number(&wp->window->options, "wrap-search");
1.21 nicm 1054: searchlen = screen_write_strlen(utf8flag, "%s", searchstr);
1055:
1056: screen_init(&ss, searchlen, 1, 0);
1057: screen_write_start(&ctx, NULL, &ss);
1058: memcpy(&gc, &grid_default_cell, sizeof gc);
1059: screen_write_nputs(&ctx, -1, &gc, utf8flag, "%s", searchstr);
1060: screen_write_stop(&ctx);
1061:
1062: fx = data->cx;
1063: fy = gd->hsize - data->oy + data->cy;
1064:
1065: if (fx == 0) {
1066: if (fy == 0)
1067: return;
1068: fx = gd->sx - 1;
1069: fy--;
1070: } else
1071: fx--;
1072: n = wrapped = 0;
1073:
1.97 nicm 1074: cis = 1;
1075: for (ptr = searchstr; *ptr != '\0'; ptr++) {
1.98 deraadt 1076: if (*ptr != tolower((u_char)*ptr)) {
1.97 nicm 1077: cis = 0;
1078: break;
1079: }
1080: }
1081:
1.21 nicm 1082: retry:
1083: sgd = ss.grid;
1084: for (i = fy + 1; i > 0; i--) {
1085: last = screen_size_x(s);
1086: if (i == fy + 1)
1087: last = fx;
1.97 nicm 1088: n = window_copy_search_rl(gd, sgd, &px, i - 1, 0, last, cis);
1.21 nicm 1089: if (n) {
1090: window_copy_scroll_to(wp, px, i - 1);
1091: break;
1092: }
1093: }
1.78 nicm 1094: if (wrapflag && !n && !wrapped) {
1.21 nicm 1095: fx = gd->sx - 1;
1096: fy = gd->hsize + gd->sy - 1;
1097: wrapped = 1;
1098: goto retry;
1099: }
1100:
1101: screen_free(&ss);
1102: }
1103:
1104: void
1105: window_copy_search_down(struct window_pane *wp, const char *searchstr)
1106: {
1107: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 1108: struct screen *s = data->backing, ss;
1.21 nicm 1109: struct screen_write_ctx ctx;
1110: struct grid *gd = s->grid, *sgd;
1111: struct grid_cell gc;
1112: size_t searchlen;
1113: u_int i, first, fx, fy, px;
1.97 nicm 1114: int utf8flag, n, wrapped, wrapflag, cis;
1115: const char *ptr;
1.21 nicm 1116:
1117: if (*searchstr == '\0')
1118: return;
1119: utf8flag = options_get_number(&wp->window->options, "utf8");
1.78 nicm 1120: wrapflag = options_get_number(&wp->window->options, "wrap-search");
1.21 nicm 1121: searchlen = screen_write_strlen(utf8flag, "%s", searchstr);
1122:
1123: screen_init(&ss, searchlen, 1, 0);
1124: screen_write_start(&ctx, NULL, &ss);
1125: memcpy(&gc, &grid_default_cell, sizeof gc);
1126: screen_write_nputs(&ctx, -1, &gc, utf8flag, "%s", searchstr);
1127: screen_write_stop(&ctx);
1128:
1129: fx = data->cx;
1130: fy = gd->hsize - data->oy + data->cy;
1131:
1132: if (fx == gd->sx - 1) {
1133: if (fy == gd->hsize + gd->sy)
1134: return;
1135: fx = 0;
1136: fy++;
1137: } else
1138: fx++;
1139: n = wrapped = 0;
1140:
1.97 nicm 1141: cis = 1;
1142: for (ptr = searchstr; *ptr != '\0'; ptr++) {
1.98 deraadt 1143: if (*ptr != tolower((u_char)*ptr)) {
1.97 nicm 1144: cis = 0;
1145: break;
1146: }
1147: }
1148:
1.21 nicm 1149: retry:
1150: sgd = ss.grid;
1.83 nicm 1151: for (i = fy + 1; i < gd->hsize + gd->sy + 1; i++) {
1.21 nicm 1152: first = 0;
1153: if (i == fy + 1)
1154: first = fx;
1.97 nicm 1155: n = window_copy_search_lr(gd, sgd, &px, i - 1, first, gd->sx,
1156: cis);
1.21 nicm 1157: if (n) {
1158: window_copy_scroll_to(wp, px, i - 1);
1159: break;
1160: }
1161: }
1.78 nicm 1162: if (wrapflag && !n && !wrapped) {
1.21 nicm 1163: fx = 0;
1164: fy = 0;
1165: wrapped = 1;
1166: goto retry;
1167: }
1168:
1169: screen_free(&ss);
1170: }
1171:
1172: void
1173: window_copy_goto_line(struct window_pane *wp, const char *linestr)
1174: {
1175: struct window_copy_mode_data *data = wp->modedata;
1176: const char *errstr;
1177: u_int lineno;
1178:
1.54 nicm 1179: lineno = strtonum(linestr, 0, screen_hsize(data->backing), &errstr);
1.21 nicm 1180: if (errstr != NULL)
1181: return;
1.35 nicm 1182:
1.21 nicm 1183: data->oy = lineno;
1.96 nicm 1184: window_copy_update_selection(wp, 1);
1.21 nicm 1185: window_copy_redraw_screen(wp);
1186: }
1187:
1188: void
1.18 nicm 1189: window_copy_write_line(
1190: struct window_pane *wp, struct screen_write_ctx *ctx, u_int py)
1.1 nicm 1191: {
1192: struct window_copy_mode_data *data = wp->modedata;
1193: struct screen *s = &data->screen;
1.27 nicm 1194: struct options *oo = &wp->window->options;
1.1 nicm 1195: struct grid_cell gc;
1.100 nicm 1196: char hdr[512];
1197: size_t last, xoff = 0, size = 0, limit;
1.21 nicm 1198:
1.101 nicm 1199: style_apply(&gc, oo, "mode-style");
1.1 nicm 1200:
1.21 nicm 1201: last = screen_size_y(s) - 1;
1.1 nicm 1202: if (py == 0) {
1203: size = xsnprintf(hdr, sizeof hdr,
1.54 nicm 1204: "[%u/%u]", data->oy, screen_hsize(data->backing));
1.62 nicm 1205: if (size > screen_size_x(s))
1206: size = screen_size_x(s);
1.1 nicm 1207: screen_write_cursormove(ctx, screen_size_x(s) - size, 0);
1208: screen_write_puts(ctx, &gc, "%s", hdr);
1.21 nicm 1209: } else if (py == last && data->inputtype != WINDOW_COPY_OFF) {
1.100 nicm 1210: limit = sizeof hdr;
1.105 nicm 1211: if (limit > screen_size_x(s) + 1)
1212: limit = screen_size_x(s) + 1;
1.50 nicm 1213: if (data->inputtype == WINDOW_COPY_NUMERICPREFIX) {
1.100 nicm 1214: xoff = size = xsnprintf(hdr, limit,
1.50 nicm 1215: "Repeat: %u", data->numprefix);
1216: } else {
1.100 nicm 1217: xoff = size = xsnprintf(hdr, limit,
1.50 nicm 1218: "%s: %s", data->inputprompt, data->inputstr);
1219: }
1.21 nicm 1220: screen_write_cursormove(ctx, 0, last);
1221: screen_write_puts(ctx, &gc, "%s", hdr);
1.1 nicm 1222: } else
1223: size = 0;
1224:
1.105 nicm 1225: if (size < screen_size_x(s)) {
1226: screen_write_cursormove(ctx, xoff, py);
1227: screen_write_copy(ctx, data->backing, xoff,
1228: (screen_hsize(data->backing) - data->oy) + py,
1229: screen_size_x(s) - size, 1);
1230: }
1.18 nicm 1231:
1232: if (py == data->cy && data->cx == screen_size_x(s)) {
1233: memcpy(&gc, &grid_default_cell, sizeof gc);
1234: screen_write_cursormove(ctx, screen_size_x(s) - 1, py);
1235: screen_write_putc(ctx, &gc, '$');
1236: }
1.1 nicm 1237: }
1238:
1239: void
1240: window_copy_write_lines(
1241: struct window_pane *wp, struct screen_write_ctx *ctx, u_int py, u_int ny)
1242: {
1243: u_int yy;
1244:
1245: for (yy = py; yy < py + ny; yy++)
1246: window_copy_write_line(wp, ctx, py);
1247: }
1248:
1249: void
1250: window_copy_redraw_lines(struct window_pane *wp, u_int py, u_int ny)
1251: {
1252: struct window_copy_mode_data *data = wp->modedata;
1253: struct screen_write_ctx ctx;
1254: u_int i;
1255:
1256: screen_write_start(&ctx, wp, NULL);
1257: for (i = py; i < py + ny; i++)
1258: window_copy_write_line(wp, &ctx, i);
1259: screen_write_cursormove(&ctx, data->cx, data->cy);
1260: screen_write_stop(&ctx);
1261: }
1262:
1263: void
1264: window_copy_redraw_screen(struct window_pane *wp)
1265: {
1266: struct window_copy_mode_data *data = wp->modedata;
1267:
1268: window_copy_redraw_lines(wp, 0, screen_size_y(&data->screen));
1269: }
1270:
1271: void
1.18 nicm 1272: window_copy_update_cursor(struct window_pane *wp, u_int cx, u_int cy)
1.1 nicm 1273: {
1274: struct window_copy_mode_data *data = wp->modedata;
1.18 nicm 1275: struct screen *s = &data->screen;
1.1 nicm 1276: struct screen_write_ctx ctx;
1.18 nicm 1277: u_int old_cx, old_cy;
1.1 nicm 1278:
1.18 nicm 1279: old_cx = data->cx; old_cy = data->cy;
1280: data->cx = cx; data->cy = cy;
1281: if (old_cx == screen_size_x(s))
1282: window_copy_redraw_lines(wp, old_cy, 1);
1283: if (data->cx == screen_size_x(s))
1284: window_copy_redraw_lines(wp, data->cy, 1);
1285: else {
1286: screen_write_start(&ctx, wp, NULL);
1287: screen_write_cursormove(&ctx, data->cx, data->cy);
1288: screen_write_stop(&ctx);
1289: }
1.1 nicm 1290: }
1291:
1292: void
1293: window_copy_start_selection(struct window_pane *wp)
1294: {
1295: struct window_copy_mode_data *data = wp->modedata;
1296: struct screen *s = &data->screen;
1297:
1.18 nicm 1298: data->selx = data->cx;
1.54 nicm 1299: data->sely = screen_hsize(data->backing) + data->cy - data->oy;
1.1 nicm 1300:
1301: s->sel.flag = 1;
1.96 nicm 1302: window_copy_update_selection(wp, 1);
1.1 nicm 1303: }
1304:
1305: int
1.96 nicm 1306: window_copy_update_selection(struct window_pane *wp, int may_redraw)
1.1 nicm 1307: {
1308: struct window_copy_mode_data *data = wp->modedata;
1309: struct screen *s = &data->screen;
1.27 nicm 1310: struct options *oo = &wp->window->options;
1.1 nicm 1311: struct grid_cell gc;
1.42 nicm 1312: u_int sx, sy, ty, cy;
1.1 nicm 1313:
1314: if (!s->sel.flag)
1315: return (0);
1316:
1317: /* Set colours. */
1.101 nicm 1318: style_apply(&gc, oo, "mode-style");
1.1 nicm 1319:
1.18 nicm 1320: /* Find top of screen. */
1.54 nicm 1321: ty = screen_hsize(data->backing) - data->oy;
1.1 nicm 1322:
1323: /* Adjust the selection. */
1324: sx = data->selx;
1325: sy = data->sely;
1.18 nicm 1326: if (sy < ty) { /* above screen */
1.42 nicm 1327: if (!data->rectflag)
1328: sx = 0;
1.1 nicm 1329: sy = 0;
1.18 nicm 1330: } else if (sy > ty + screen_size_y(s) - 1) { /* below screen */
1.42 nicm 1331: if (!data->rectflag)
1332: sx = screen_size_x(s) - 1;
1.1 nicm 1333: sy = screen_size_y(s) - 1;
1.18 nicm 1334: } else
1.1 nicm 1335: sy -= ty;
1336: sy = screen_hsize(s) + sy;
1337:
1.42 nicm 1338: screen_set_selection(s,
1339: sx, sy, data->cx, screen_hsize(s) + data->cy, data->rectflag, &gc);
1340:
1.96 nicm 1341: if (data->rectflag && may_redraw) {
1.42 nicm 1342: /*
1343: * Can't rely on the caller to redraw the right lines for
1344: * rectangle selection - find the highest line and the number
1345: * of lines, and redraw just past that in both directions
1346: */
1347: cy = data->cy;
1348: if (sy < cy)
1349: window_copy_redraw_lines(wp, sy, cy - sy + 1);
1350: else
1351: window_copy_redraw_lines(wp, cy, sy - cy + 1);
1352: }
1353:
1.1 nicm 1354: return (1);
1355: }
1356:
1.89 nicm 1357: void *
1358: window_copy_get_selection(struct window_pane *wp, size_t *len)
1.1 nicm 1359: {
1360: struct window_copy_mode_data *data = wp->modedata;
1361: struct screen *s = &data->screen;
1362: char *buf;
1.42 nicm 1363: size_t off;
1.111 nicm 1364: u_int i, xx, yy, sx, sy, ex, ey, ey_last;
1.42 nicm 1365: u_int firstsx, lastex, restex, restsx;
1.69 nicm 1366: int keys;
1.1 nicm 1367:
1368: if (!s->sel.flag)
1.89 nicm 1369: return (NULL);
1.1 nicm 1370:
1371: buf = xmalloc(1);
1372: off = 0;
1373:
1374: *buf = '\0';
1375:
1376: /*
1377: * The selection extends from selx,sely to (adjusted) cx,cy on
1378: * the base screen.
1379: */
1380:
1381: /* Find start and end. */
1.18 nicm 1382: xx = data->cx;
1.54 nicm 1383: yy = screen_hsize(data->backing) + data->cy - data->oy;
1.2 nicm 1384: if (yy < data->sely || (yy == data->sely && xx < data->selx)) {
1.1 nicm 1385: sx = xx; sy = yy;
1386: ex = data->selx; ey = data->sely;
1387: } else {
1388: sx = data->selx; sy = data->sely;
1389: ex = xx; ey = yy;
1390: }
1391:
1392: /* Trim ex to end of line. */
1.111 nicm 1393: ey_last = window_copy_find_length(wp, ey);
1394: if (ex > ey_last)
1395: ex = ey_last;
1.1 nicm 1396:
1.42 nicm 1397: /*
1398: * Deal with rectangle-copy if necessary; four situations: start of
1399: * first line (firstsx), end of last line (lastex), start (restsx) and
1400: * end (restex) of all other lines.
1401: */
1402: xx = screen_size_x(s);
1.69 nicm 1403:
1404: /*
1405: * Behave according to mode-keys. If it is emacs, copy like emacs,
1406: * keeping the top-left-most character, and dropping the
1407: * bottom-right-most, regardless of copy direction. If it is vi, also
1408: * keep bottom-right-most character.
1409: */
1410: keys = options_get_number(&wp->window->options, "mode-keys");
1.42 nicm 1411: if (data->rectflag) {
1412: /*
1413: * Need to ignore the column with the cursor in it, which for
1414: * rectangular copy means knowing which side the cursor is on.
1415: */
1416: if (data->selx < data->cx) {
1417: /* Selection start is on the left. */
1.69 nicm 1418: if (keys == MODEKEY_EMACS) {
1419: lastex = data->cx;
1420: restex = data->cx;
1421: }
1422: else {
1423: lastex = data->cx + 1;
1424: restex = data->cx + 1;
1425: }
1.42 nicm 1426: firstsx = data->selx;
1427: restsx = data->selx;
1428: } else {
1429: /* Cursor is on the left. */
1430: lastex = data->selx + 1;
1431: restex = data->selx + 1;
1.64 nicm 1432: firstsx = data->cx;
1433: restsx = data->cx;
1.42 nicm 1434: }
1435: } else {
1.69 nicm 1436: if (keys == MODEKEY_EMACS)
1437: lastex = ex;
1.74 nicm 1438: else
1.69 nicm 1439: lastex = ex + 1;
1.42 nicm 1440: restex = xx;
1441: firstsx = sx;
1442: restsx = 0;
1443: }
1444:
1.1 nicm 1445: /* Copy the lines. */
1.110 nicm 1446: for (i = sy; i <= ey; i++) {
1447: window_copy_copy_line(wp, &buf, &off, i,
1448: (i == sy ? firstsx : restsx),
1449: (i == ey ? lastex : restex));
1.1 nicm 1450: }
1451:
1.26 nicm 1452: /* Don't bother if no data. */
1453: if (off == 0) {
1.81 nicm 1454: free(buf);
1.89 nicm 1455: return (NULL);
1.26 nicm 1456: }
1.111 nicm 1457: if (keys == MODEKEY_EMACS || lastex <= ey_last)
1458: off -= 1; /* remove final \n (unless at end in vi mode) */
1459: *len = off;
1.89 nicm 1460: return (buf);
1461: }
1462:
1463: void
1.108 nicm 1464: window_copy_copy_buffer(struct window_pane *wp, const char *bufname, void *buf,
1465: size_t len)
1.89 nicm 1466: {
1.91 nicm 1467: struct screen_write_ctx ctx;
1.72 nicm 1468:
1.91 nicm 1469: if (options_get_number(&global_options, "set-clipboard")) {
1470: screen_write_start(&ctx, wp, NULL);
1471: screen_write_setselection(&ctx, buf, len);
1472: screen_write_stop(&ctx);
1473: }
1.1 nicm 1474:
1.108 nicm 1475: if (paste_set(buf, len, bufname, NULL) != 0)
1.102 nicm 1476: free(buf);
1.89 nicm 1477: }
1478:
1479: void
1.108 nicm 1480: window_copy_copy_pipe(struct window_pane *wp, struct session *sess,
1481: const char *bufname, const char *arg)
1.89 nicm 1482: {
1.90 nicm 1483: void *buf;
1484: size_t len;
1485: struct job *job;
1486:
1.89 nicm 1487:
1488: buf = window_copy_get_selection(wp, &len);
1489: if (buf == NULL)
1490: return;
1491:
1.90 nicm 1492: job = job_run(arg, sess, NULL, NULL, NULL);
1493: bufferevent_write(job->event, buf, len);
1.89 nicm 1494:
1.108 nicm 1495: window_copy_copy_buffer(wp, bufname, buf, len);
1.89 nicm 1496: }
1497:
1498: void
1.108 nicm 1499: window_copy_copy_selection(struct window_pane *wp, const char *bufname)
1.89 nicm 1500: {
1501: void* buf;
1502: size_t len;
1503:
1504: buf = window_copy_get_selection(wp, &len);
1505: if (buf == NULL)
1506: return;
1507:
1.108 nicm 1508: window_copy_copy_buffer(wp, bufname, buf, len);
1.103 nicm 1509: }
1510:
1511: void
1.108 nicm 1512: window_copy_append_selection(struct window_pane *wp, const char *bufname)
1.103 nicm 1513: {
1.108 nicm 1514: char *buf;
1515: struct paste_buffer *pb;
1516: size_t len;
1517: struct screen_write_ctx ctx;
1.103 nicm 1518:
1519: buf = window_copy_get_selection(wp, &len);
1520: if (buf == NULL)
1521: return;
1522:
1523: if (options_get_number(&global_options, "set-clipboard")) {
1524: screen_write_start(&ctx, wp, NULL);
1525: screen_write_setselection(&ctx, buf, len);
1526: screen_write_stop(&ctx);
1527: }
1528:
1.108 nicm 1529: if (bufname == NULL || *bufname == '\0') {
1530: pb = paste_get_top();
1531: if (pb != NULL)
1532: bufname = pb->name;
1533: } else
1534: pb = paste_get_name(bufname);
1.103 nicm 1535: if (pb != NULL) {
1536: buf = xrealloc(buf, 1, len + pb->size);
1537: memmove(buf + pb->size, buf, len);
1538: memcpy(buf, pb->data, pb->size);
1539: len += pb->size;
1540: }
1.108 nicm 1541: if (paste_set(buf, len, bufname, NULL) != 0)
1.103 nicm 1542: free(buf);
1.1 nicm 1543: }
1544:
1545: void
1546: window_copy_copy_line(struct window_pane *wp,
1547: char **buf, size_t *off, u_int sy, u_int sx, u_int ex)
1548: {
1.54 nicm 1549: struct window_copy_mode_data *data = wp->modedata;
1550: struct grid *gd = data->backing->grid;
1551: const struct grid_cell *gc;
1552: struct grid_line *gl;
1.86 nicm 1553: struct utf8_data ud;
1.54 nicm 1554: u_int i, xx, wrapped = 0;
1.1 nicm 1555:
1556: if (sx > ex)
1557: return;
1558:
1.16 nicm 1559: /*
1560: * Work out if the line was wrapped at the screen edge and all of it is
1561: * on screen.
1562: */
1563: gl = &gd->linedata[sy];
1.35 nicm 1564: if (gl->flags & GRID_LINE_WRAPPED && gl->cellsize <= gd->sx)
1.16 nicm 1565: wrapped = 1;
1566:
1567: /* If the line was wrapped, don't strip spaces (use the full length). */
1568: if (wrapped)
1569: xx = gl->cellsize;
1570: else
1571: xx = window_copy_find_length(wp, sy);
1.1 nicm 1572: if (ex > xx)
1573: ex = xx;
1574: if (sx > xx)
1575: sx = xx;
1576:
1577: if (sx < ex) {
1578: for (i = sx; i < ex; i++) {
1.16 nicm 1579: gc = grid_peek_cell(gd, i, sy);
1.1 nicm 1580: if (gc->flags & GRID_FLAG_PADDING)
1581: continue;
1.86 nicm 1582: grid_cell_get(gc, &ud);
1583:
1584: *buf = xrealloc(*buf, 1, (*off) + ud.size);
1585: memcpy(*buf + *off, ud.data, ud.size);
1586: *off += ud.size;
1.1 nicm 1587: }
1588: }
1589:
1.16 nicm 1590: /* Only add a newline if the line wasn't wrapped. */
1.44 nicm 1591: if (!wrapped || ex != xx) {
1.16 nicm 1592: *buf = xrealloc(*buf, 1, (*off) + 1);
1593: (*buf)[(*off)++] = '\n';
1594: }
1.1 nicm 1595: }
1596:
1.47 nicm 1597: void
1598: window_copy_clear_selection(struct window_pane *wp)
1599: {
1600: struct window_copy_mode_data *data = wp->modedata;
1601: u_int px, py;
1602:
1603: screen_clear_selection(&data->screen);
1604:
1.54 nicm 1605: py = screen_hsize(data->backing) + data->cy - data->oy;
1.47 nicm 1606: px = window_copy_find_length(wp, py);
1607: if (data->cx > px)
1608: window_copy_update_cursor(wp, px, data->cy);
1609: }
1610:
1.1 nicm 1611: int
1.41 nicm 1612: window_copy_in_set(struct window_pane *wp, u_int px, u_int py, const char *set)
1.1 nicm 1613: {
1.54 nicm 1614: struct window_copy_mode_data *data = wp->modedata;
1615: const struct grid_cell *gc;
1.86 nicm 1616: struct utf8_data ud;
1.1 nicm 1617:
1.54 nicm 1618: gc = grid_peek_cell(data->backing->grid, px, py);
1.86 nicm 1619: grid_cell_get(gc, &ud);
1620: if (ud.size != 1 || gc->flags & GRID_FLAG_PADDING)
1.1 nicm 1621: return (0);
1.86 nicm 1622: if (*ud.data == 0x00 || *ud.data == 0x7f)
1.1 nicm 1623: return (0);
1.86 nicm 1624: return (strchr(set, *ud.data) != NULL);
1.1 nicm 1625: }
1626:
1627: u_int
1628: window_copy_find_length(struct window_pane *wp, u_int py)
1629: {
1.54 nicm 1630: struct window_copy_mode_data *data = wp->modedata;
1631: struct screen *s = data->backing;
1632: const struct grid_cell *gc;
1.86 nicm 1633: struct utf8_data ud;
1.54 nicm 1634: u_int px;
1.1 nicm 1635:
1.4 nicm 1636: /*
1637: * If the pane has been resized, its grid can contain old overlong
1638: * lines. grid_peek_cell does not allow accessing cells beyond the
1639: * width of the grid, and screen_write_copy treats them as spaces, so
1640: * ignore them here too.
1641: */
1.54 nicm 1642: px = s->grid->linedata[py].cellsize;
1643: if (px > screen_size_x(s))
1644: px = screen_size_x(s);
1.1 nicm 1645: while (px > 0) {
1.54 nicm 1646: gc = grid_peek_cell(s->grid, px - 1, py);
1.86 nicm 1647: grid_cell_get(gc, &ud);
1648: if (ud.size != 1 || *ud.data != ' ')
1.1 nicm 1649: break;
1650: px--;
1651: }
1652: return (px);
1653: }
1654:
1655: void
1.5 nicm 1656: window_copy_cursor_start_of_line(struct window_pane *wp)
1657: {
1658: struct window_copy_mode_data *data = wp->modedata;
1.58 nicm 1659: struct screen *back_s = data->backing;
1660: struct grid *gd = back_s->grid;
1661: u_int py;
1662:
1663: if (data->cx == 0) {
1664: py = screen_hsize(back_s) + data->cy - data->oy;
1665: while (py > 0 && gd->linedata[py-1].flags & GRID_LINE_WRAPPED) {
1666: window_copy_cursor_up(wp, 0);
1667: py = screen_hsize(back_s) + data->cy - data->oy;
1668: }
1669: }
1.18 nicm 1670: window_copy_update_cursor(wp, 0, data->cy);
1.96 nicm 1671: if (window_copy_update_selection(wp, 1))
1.5 nicm 1672: window_copy_redraw_lines(wp, data->cy, 1);
1.6 nicm 1673: }
1674:
1675: void
1676: window_copy_cursor_back_to_indentation(struct window_pane *wp)
1677: {
1678: struct window_copy_mode_data *data = wp->modedata;
1679: u_int px, py, xx;
1680: const struct grid_cell *gc;
1.86 nicm 1681: struct utf8_data ud;
1.6 nicm 1682:
1683: px = 0;
1.54 nicm 1684: py = screen_hsize(data->backing) + data->cy - data->oy;
1.6 nicm 1685: xx = window_copy_find_length(wp, py);
1686:
1687: while (px < xx) {
1.54 nicm 1688: gc = grid_peek_cell(data->backing->grid, px, py);
1.86 nicm 1689: grid_cell_get(gc, &ud);
1690: if (ud.size != 1 || *ud.data != ' ')
1.6 nicm 1691: break;
1692: px++;
1693: }
1694:
1.18 nicm 1695: window_copy_update_cursor(wp, px, data->cy);
1.96 nicm 1696: if (window_copy_update_selection(wp, 1))
1.18 nicm 1697: window_copy_redraw_lines(wp, data->cy, 1);
1.5 nicm 1698: }
1699:
1700: void
1701: window_copy_cursor_end_of_line(struct window_pane *wp)
1702: {
1703: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 1704: struct screen *back_s = data->backing;
1705: struct grid *gd = back_s->grid;
1.5 nicm 1706: u_int px, py;
1707:
1.54 nicm 1708: py = screen_hsize(back_s) + data->cy - data->oy;
1.5 nicm 1709: px = window_copy_find_length(wp, py);
1710:
1.49 nicm 1711: if (data->cx == px) {
1712: if (data->screen.sel.flag && data->rectflag)
1.54 nicm 1713: px = screen_size_x(back_s);
1.49 nicm 1714: if (gd->linedata[py].flags & GRID_LINE_WRAPPED) {
1715: while (py < gd->sy + gd->hsize &&
1716: gd->linedata[py].flags & GRID_LINE_WRAPPED) {
1717: window_copy_cursor_down(wp, 0);
1.54 nicm 1718: py = screen_hsize(back_s)
1719: + data->cy - data->oy;
1.49 nicm 1720: }
1721: px = window_copy_find_length(wp, py);
1722: }
1723: }
1.18 nicm 1724: window_copy_update_cursor(wp, px, data->cy);
1.49 nicm 1725:
1.96 nicm 1726: if (window_copy_update_selection(wp, 1))
1.18 nicm 1727: window_copy_redraw_lines(wp, data->cy, 1);
1.95 nicm 1728: }
1729:
1730: void
1731: window_copy_other_end(struct window_pane *wp)
1732: {
1733: struct window_copy_mode_data *data = wp->modedata;
1734: struct screen *s = &data->screen;
1735: u_int selx, sely, cx, cy, yy;
1736:
1737: if (!s->sel.flag)
1738: return;
1739:
1740: selx = data->selx;
1741: sely = data->sely;
1742: cx = data->cx;
1743: cy = data->cy;
1744: yy = screen_hsize(data->backing) + data->cy - data->oy;
1745:
1746: data->selx = cx;
1747: data->sely = yy;
1748: data->cx = selx;
1749:
1750: if (sely < screen_hsize(data->backing) - data->oy) {
1751: data->oy = screen_hsize(data->backing) - sely;
1752: data->cy = 0;
1753: } else if (sely > screen_hsize(data->backing) - data->oy + screen_size_y(s)) {
1754: data->oy = screen_hsize(data->backing) - sely + screen_size_y(s) - 1;
1755: data->cy = screen_size_y(s) - 1;
1756:
1757: } else
1758: data->cy = cy + sely - yy;
1759:
1760: window_copy_redraw_screen(wp);
1.5 nicm 1761: }
1762:
1763: void
1.1 nicm 1764: window_copy_cursor_left(struct window_pane *wp)
1765: {
1766: struct window_copy_mode_data *data = wp->modedata;
1767:
1768: if (data->cx == 0) {
1.28 nicm 1769: window_copy_cursor_up(wp, 0);
1.18 nicm 1770: window_copy_cursor_end_of_line(wp);
1.1 nicm 1771: } else {
1.18 nicm 1772: window_copy_update_cursor(wp, data->cx - 1, data->cy);
1.96 nicm 1773: if (window_copy_update_selection(wp, 1))
1.1 nicm 1774: window_copy_redraw_lines(wp, data->cy, 1);
1775: }
1776: }
1777:
1778: void
1779: window_copy_cursor_right(struct window_pane *wp)
1780: {
1781: struct window_copy_mode_data *data = wp->modedata;
1782: u_int px, py;
1783:
1.47 nicm 1784: if (data->screen.sel.flag && data->rectflag)
1785: px = screen_size_x(&data->screen);
1786: else {
1.54 nicm 1787: py = screen_hsize(data->backing) + data->cy - data->oy;
1.47 nicm 1788: px = window_copy_find_length(wp, py);
1789: }
1.1 nicm 1790:
1791: if (data->cx >= px) {
1792: window_copy_cursor_start_of_line(wp);
1.28 nicm 1793: window_copy_cursor_down(wp, 0);
1.1 nicm 1794: } else {
1.18 nicm 1795: window_copy_update_cursor(wp, data->cx + 1, data->cy);
1.96 nicm 1796: if (window_copy_update_selection(wp, 1))
1.1 nicm 1797: window_copy_redraw_lines(wp, data->cy, 1);
1798: }
1799: }
1800:
1801: void
1.28 nicm 1802: window_copy_cursor_up(struct window_pane *wp, int scroll_only)
1.1 nicm 1803: {
1804: struct window_copy_mode_data *data = wp->modedata;
1.36 nicm 1805: struct screen *s = &data->screen;
1.1 nicm 1806: u_int ox, oy, px, py;
1807:
1.54 nicm 1808: oy = screen_hsize(data->backing) + data->cy - data->oy;
1.1 nicm 1809: ox = window_copy_find_length(wp, oy);
1.77 nicm 1810: if (data->cx != ox) {
1.25 nicm 1811: data->lastcx = data->cx;
1812: data->lastsx = ox;
1813: }
1.1 nicm 1814:
1.25 nicm 1815: data->cx = data->lastcx;
1.28 nicm 1816: if (scroll_only || data->cy == 0) {
1.1 nicm 1817: window_copy_scroll_down(wp, 1);
1.36 nicm 1818: if (scroll_only) {
1819: if (data->cy == screen_size_y(s) - 1)
1820: window_copy_redraw_lines(wp, data->cy, 1);
1821: else
1822: window_copy_redraw_lines(wp, data->cy, 2);
1823: }
1.28 nicm 1824: } else {
1.18 nicm 1825: window_copy_update_cursor(wp, data->cx, data->cy - 1);
1.96 nicm 1826: if (window_copy_update_selection(wp, 1)) {
1.36 nicm 1827: if (data->cy == screen_size_y(s) - 1)
1828: window_copy_redraw_lines(wp, data->cy, 1);
1829: else
1830: window_copy_redraw_lines(wp, data->cy, 2);
1831: }
1.1 nicm 1832: }
1833:
1.47 nicm 1834: if (!data->screen.sel.flag || !data->rectflag) {
1.54 nicm 1835: py = screen_hsize(data->backing) + data->cy - data->oy;
1.47 nicm 1836: px = window_copy_find_length(wp, py);
1.49 nicm 1837: if ((data->cx >= data->lastsx && data->cx != px) ||
1838: data->cx > px)
1.47 nicm 1839: window_copy_cursor_end_of_line(wp);
1840: }
1.1 nicm 1841: }
1842:
1843: void
1.28 nicm 1844: window_copy_cursor_down(struct window_pane *wp, int scroll_only)
1.1 nicm 1845: {
1846: struct window_copy_mode_data *data = wp->modedata;
1847: struct screen *s = &data->screen;
1848: u_int ox, oy, px, py;
1849:
1.54 nicm 1850: oy = screen_hsize(data->backing) + data->cy - data->oy;
1.1 nicm 1851: ox = window_copy_find_length(wp, oy);
1.77 nicm 1852: if (data->cx != ox) {
1.25 nicm 1853: data->lastcx = data->cx;
1854: data->lastsx = ox;
1855: }
1.1 nicm 1856:
1.25 nicm 1857: data->cx = data->lastcx;
1.28 nicm 1858: if (scroll_only || data->cy == screen_size_y(s) - 1) {
1.1 nicm 1859: window_copy_scroll_up(wp, 1);
1.31 nicm 1860: if (scroll_only && data->cy > 0)
1.28 nicm 1861: window_copy_redraw_lines(wp, data->cy - 1, 2);
1862: } else {
1.18 nicm 1863: window_copy_update_cursor(wp, data->cx, data->cy + 1);
1.96 nicm 1864: if (window_copy_update_selection(wp, 1))
1.1 nicm 1865: window_copy_redraw_lines(wp, data->cy - 1, 2);
1866: }
1867:
1.47 nicm 1868: if (!data->screen.sel.flag || !data->rectflag) {
1.54 nicm 1869: py = screen_hsize(data->backing) + data->cy - data->oy;
1.47 nicm 1870: px = window_copy_find_length(wp, py);
1.49 nicm 1871: if ((data->cx >= data->lastsx && data->cx != px) ||
1872: data->cx > px)
1.47 nicm 1873: window_copy_cursor_end_of_line(wp);
1.52 nicm 1874: }
1875: }
1876:
1877: void
1878: window_copy_cursor_jump(struct window_pane *wp)
1879: {
1880: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 1881: struct screen *back_s = data->backing;
1.52 nicm 1882: const struct grid_cell *gc;
1.86 nicm 1883: struct utf8_data ud;
1.67 nicm 1884: u_int px, py, xx;
1.52 nicm 1885:
1886: px = data->cx + 1;
1.54 nicm 1887: py = screen_hsize(back_s) + data->cy - data->oy;
1.52 nicm 1888: xx = window_copy_find_length(wp, py);
1889:
1890: while (px < xx) {
1.54 nicm 1891: gc = grid_peek_cell(back_s->grid, px, py);
1.86 nicm 1892: grid_cell_get(gc, &ud);
1893: if (!(gc->flags & GRID_FLAG_PADDING) &&
1894: ud.size == 1 && *ud.data == data->jumpchar) {
1.52 nicm 1895: window_copy_update_cursor(wp, px, data->cy);
1.96 nicm 1896: if (window_copy_update_selection(wp, 1))
1.52 nicm 1897: window_copy_redraw_lines(wp, data->cy, 1);
1898: return;
1899: }
1900: px++;
1901: }
1902: }
1903:
1904: void
1905: window_copy_cursor_jump_back(struct window_pane *wp)
1906: {
1907: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 1908: struct screen *back_s = data->backing;
1.52 nicm 1909: const struct grid_cell *gc;
1.86 nicm 1910: struct utf8_data ud;
1.67 nicm 1911: u_int px, py;
1.52 nicm 1912:
1913: px = data->cx;
1.54 nicm 1914: py = screen_hsize(back_s) + data->cy - data->oy;
1.52 nicm 1915:
1916: if (px > 0)
1917: px--;
1918:
1919: for (;;) {
1.54 nicm 1920: gc = grid_peek_cell(back_s->grid, px, py);
1.86 nicm 1921: grid_cell_get(gc, &ud);
1922: if (!(gc->flags & GRID_FLAG_PADDING) &&
1923: ud.size == 1 && *ud.data == data->jumpchar) {
1.52 nicm 1924: window_copy_update_cursor(wp, px, data->cy);
1.96 nicm 1925: if (window_copy_update_selection(wp, 1))
1.76 nicm 1926: window_copy_redraw_lines(wp, data->cy, 1);
1927: return;
1928: }
1929: if (px == 0)
1930: break;
1931: px--;
1932: }
1933: }
1934:
1935: void
1936: window_copy_cursor_jump_to(struct window_pane *wp)
1937: {
1938: struct window_copy_mode_data *data = wp->modedata;
1939: struct screen *back_s = data->backing;
1940: const struct grid_cell *gc;
1.86 nicm 1941: struct utf8_data ud;
1.76 nicm 1942: u_int px, py, xx;
1943:
1944: px = data->cx + 1;
1945: py = screen_hsize(back_s) + data->cy - data->oy;
1946: xx = window_copy_find_length(wp, py);
1947:
1948: while (px < xx) {
1949: gc = grid_peek_cell(back_s->grid, px, py);
1.86 nicm 1950: grid_cell_get(gc, &ud);
1951: if (!(gc->flags & GRID_FLAG_PADDING) &&
1952: ud.size == 1 && *ud.data == data->jumpchar) {
1.76 nicm 1953: window_copy_update_cursor(wp, px - 1, data->cy);
1.96 nicm 1954: if (window_copy_update_selection(wp, 1))
1.76 nicm 1955: window_copy_redraw_lines(wp, data->cy, 1);
1956: return;
1957: }
1958: px++;
1959: }
1960: }
1961:
1962: void
1963: window_copy_cursor_jump_to_back(struct window_pane *wp)
1964: {
1965: struct window_copy_mode_data *data = wp->modedata;
1966: struct screen *back_s = data->backing;
1967: const struct grid_cell *gc;
1.86 nicm 1968: struct utf8_data ud;
1.76 nicm 1969: u_int px, py;
1970:
1971: px = data->cx;
1972: py = screen_hsize(back_s) + data->cy - data->oy;
1973:
1974: if (px > 0)
1975: px--;
1976:
1977: for (;;) {
1978: gc = grid_peek_cell(back_s->grid, px, py);
1.86 nicm 1979: grid_cell_get(gc, &ud);
1980: if (!(gc->flags & GRID_FLAG_PADDING) &&
1981: ud.size == 1 && *ud.data == data->jumpchar) {
1.76 nicm 1982: window_copy_update_cursor(wp, px + 1, data->cy);
1.96 nicm 1983: if (window_copy_update_selection(wp, 1))
1.52 nicm 1984: window_copy_redraw_lines(wp, data->cy, 1);
1985: return;
1986: }
1987: if (px == 0)
1988: break;
1989: px--;
1.47 nicm 1990: }
1.1 nicm 1991: }
1992:
1993: void
1.41 nicm 1994: window_copy_cursor_next_word(struct window_pane *wp, const char *separators)
1.40 nicm 1995: {
1996: struct window_copy_mode_data *data = wp->modedata;
1.54 nicm 1997: struct screen *back_s = data->backing;
1.40 nicm 1998: u_int px, py, xx, yy;
1.48 nicm 1999: int expected = 0;
1.40 nicm 2000:
2001: px = data->cx;
1.54 nicm 2002: py = screen_hsize(back_s) + data->cy - data->oy;
1.40 nicm 2003: xx = window_copy_find_length(wp, py);
1.54 nicm 2004: yy = screen_hsize(back_s) + screen_size_y(back_s) - 1;
1.40 nicm 2005:
1.48 nicm 2006: /*
2007: * First skip past any nonword characters and then any word characters.
2008: *
2009: * expected is initially set to 0 for the former and then 1 for the
2010: * latter.
2011: */
2012: do {
2013: while (px > xx ||
2014: window_copy_in_set(wp, px, py, separators) == expected) {
2015: /* Move down if we're past the end of the line. */
2016: if (px > xx) {
2017: if (py == yy)
2018: return;
2019: window_copy_cursor_down(wp, 0);
2020: px = 0;
2021:
1.54 nicm 2022: py = screen_hsize(back_s) + data->cy - data->oy;
1.48 nicm 2023: xx = window_copy_find_length(wp, py);
2024: } else
2025: px++;
2026: }
2027: expected = !expected;
2028: } while (expected == 1);
1.40 nicm 2029:
2030: window_copy_update_cursor(wp, px, data->cy);
1.96 nicm 2031: if (window_copy_update_selection(wp, 1))
1.40 nicm 2032: window_copy_redraw_lines(wp, data->cy, 1);
2033: }
2034:
2035: void
1.106 nicm 2036: window_copy_cursor_next_word_end(struct window_pane *wp,
2037: const char *separators)
1.1 nicm 2038: {
2039: struct window_copy_mode_data *data = wp->modedata;
1.92 nicm 2040: struct options *oo = &wp->window->options;
1.54 nicm 2041: struct screen *back_s = data->backing;
1.39 nicm 2042: u_int px, py, xx, yy;
1.94 nicm 2043: int keys, expected = 1;
1.1 nicm 2044:
1.18 nicm 2045: px = data->cx;
1.54 nicm 2046: py = screen_hsize(back_s) + data->cy - data->oy;
1.1 nicm 2047: xx = window_copy_find_length(wp, py);
1.54 nicm 2048: yy = screen_hsize(back_s) + screen_size_y(back_s) - 1;
1.1 nicm 2049:
1.94 nicm 2050: keys = options_get_number(oo, "mode-keys");
2051: if (keys == MODEKEY_VI && !window_copy_in_set(wp, px, py, separators))
2052: px++;
2053:
1.48 nicm 2054: /*
2055: * First skip past any word characters, then any nonword characters.
2056: *
2057: * expected is initially set to 1 for the former and then 0 for the
2058: * latter.
2059: */
2060: do {
2061: while (px > xx ||
2062: window_copy_in_set(wp, px, py, separators) == expected) {
2063: /* Move down if we're past the end of the line. */
2064: if (px > xx) {
2065: if (py == yy)
2066: return;
2067: window_copy_cursor_down(wp, 0);
2068: px = 0;
2069:
1.54 nicm 2070: py = screen_hsize(back_s) + data->cy - data->oy;
1.48 nicm 2071: xx = window_copy_find_length(wp, py);
2072: } else
2073: px++;
2074: }
2075: expected = !expected;
2076: } while (expected == 0);
1.92 nicm 2077:
1.94 nicm 2078: if (keys == MODEKEY_VI && px != 0)
1.92 nicm 2079: px--;
1.18 nicm 2080:
2081: window_copy_update_cursor(wp, px, data->cy);
1.96 nicm 2082: if (window_copy_update_selection(wp, 1))
1.18 nicm 2083: window_copy_redraw_lines(wp, data->cy, 1);
1.1 nicm 2084: }
2085:
1.8 nicm 2086: /* Move to the previous place where a word begins. */
1.1 nicm 2087: void
1.106 nicm 2088: window_copy_cursor_previous_word(struct window_pane *wp,
2089: const char *separators)
1.1 nicm 2090: {
2091: struct window_copy_mode_data *data = wp->modedata;
1.8 nicm 2092: u_int px, py;
1.1 nicm 2093:
1.18 nicm 2094: px = data->cx;
1.54 nicm 2095: py = screen_hsize(data->backing) + data->cy - data->oy;
1.1 nicm 2096:
1.8 nicm 2097: /* Move back to the previous word character. */
1.1 nicm 2098: for (;;) {
1.8 nicm 2099: if (px > 0) {
2100: px--;
1.41 nicm 2101: if (!window_copy_in_set(wp, px, py, separators))
1.1 nicm 2102: break;
1.8 nicm 2103: } else {
2104: if (data->cy == 0 &&
1.54 nicm 2105: (screen_hsize(data->backing) == 0 ||
2106: data->oy >= screen_hsize(data->backing) - 1))
1.8 nicm 2107: goto out;
1.28 nicm 2108: window_copy_cursor_up(wp, 0);
1.1 nicm 2109:
1.54 nicm 2110: py = screen_hsize(data->backing) + data->cy - data->oy;
1.8 nicm 2111: px = window_copy_find_length(wp, py);
1.1 nicm 2112: }
1.8 nicm 2113: }
1.1 nicm 2114:
1.8 nicm 2115: /* Move back to the beginning of this word. */
1.41 nicm 2116: while (px > 0 && !window_copy_in_set(wp, px - 1, py, separators))
1.1 nicm 2117: px--;
1.8 nicm 2118:
1.1 nicm 2119: out:
1.18 nicm 2120: window_copy_update_cursor(wp, px, data->cy);
1.96 nicm 2121: if (window_copy_update_selection(wp, 1))
1.18 nicm 2122: window_copy_redraw_lines(wp, data->cy, 1);
1.1 nicm 2123: }
2124:
2125: void
2126: window_copy_scroll_up(struct window_pane *wp, u_int ny)
2127: {
2128: struct window_copy_mode_data *data = wp->modedata;
2129: struct screen *s = &data->screen;
2130: struct screen_write_ctx ctx;
2131:
2132: if (data->oy < ny)
2133: ny = data->oy;
2134: if (ny == 0)
2135: return;
2136: data->oy -= ny;
2137:
1.96 nicm 2138: window_copy_update_selection(wp, 0);
2139:
1.1 nicm 2140: screen_write_start(&ctx, wp, NULL);
2141: screen_write_cursormove(&ctx, 0, 0);
2142: screen_write_deleteline(&ctx, ny);
2143: window_copy_write_lines(wp, &ctx, screen_size_y(s) - ny, ny);
2144: window_copy_write_line(wp, &ctx, 0);
1.31 nicm 2145: if (screen_size_y(s) > 1)
2146: window_copy_write_line(wp, &ctx, 1);
2147: if (screen_size_y(s) > 3)
2148: window_copy_write_line(wp, &ctx, screen_size_y(s) - 2);
1.96 nicm 2149: if (s->sel.flag && screen_size_y(s) > ny)
1.1 nicm 2150: window_copy_write_line(wp, &ctx, screen_size_y(s) - ny - 1);
2151: screen_write_cursormove(&ctx, data->cx, data->cy);
2152: screen_write_stop(&ctx);
2153: }
2154:
2155: void
2156: window_copy_scroll_down(struct window_pane *wp, u_int ny)
2157: {
2158: struct window_copy_mode_data *data = wp->modedata;
2159: struct screen *s = &data->screen;
2160: struct screen_write_ctx ctx;
2161:
1.54 nicm 2162: if (ny > screen_hsize(data->backing))
1.1 nicm 2163: return;
2164:
1.54 nicm 2165: if (data->oy > screen_hsize(data->backing) - ny)
2166: ny = screen_hsize(data->backing) - data->oy;
1.1 nicm 2167: if (ny == 0)
2168: return;
2169: data->oy += ny;
2170:
1.96 nicm 2171: window_copy_update_selection(wp, 0);
2172:
1.1 nicm 2173: screen_write_start(&ctx, wp, NULL);
2174: screen_write_cursormove(&ctx, 0, 0);
2175: screen_write_insertline(&ctx, ny);
2176: window_copy_write_lines(wp, &ctx, 0, ny);
1.96 nicm 2177: if (s->sel.flag && screen_size_y(s) > ny)
1.1 nicm 2178: window_copy_write_line(wp, &ctx, ny);
1.96 nicm 2179: else if (ny == 1) /* nuke position */
1.1 nicm 2180: window_copy_write_line(wp, &ctx, 1);
2181: screen_write_cursormove(&ctx, data->cx, data->cy);
2182: screen_write_stop(&ctx);
2183: }
1.42 nicm 2184:
2185: void
2186: window_copy_rectangle_toggle(struct window_pane *wp)
2187: {
2188: struct window_copy_mode_data *data = wp->modedata;
1.47 nicm 2189: u_int px, py;
1.42 nicm 2190:
2191: data->rectflag = !data->rectflag;
1.47 nicm 2192:
1.54 nicm 2193: py = screen_hsize(data->backing) + data->cy - data->oy;
1.47 nicm 2194: px = window_copy_find_length(wp, py);
2195: if (data->cx > px)
2196: window_copy_update_cursor(wp, px, data->cy);
1.42 nicm 2197:
1.96 nicm 2198: window_copy_update_selection(wp, 1);
1.42 nicm 2199: window_copy_redraw_screen(wp);
2200: }
![[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