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