Annotation of src/usr.bin/tmux/window-choose.c, Revision 1.90
1.90 ! nicm 1: /* $OpenBSD: window-choose.c,v 1.89 2017/04/28 19:13:55 nicm Exp $ */
1.1 nicm 2:
3: /*
1.74 nicm 4: * Copyright (c) 2009 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.19 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:
1.79 nicm 27: static struct screen *window_choose_init(struct window_pane *);
28: static void window_choose_free(struct window_pane *);
29: static void window_choose_resize(struct window_pane *, u_int, u_int);
30: static void window_choose_key(struct window_pane *, struct client *,
31: struct session *, key_code, struct mouse_event *);
32:
33: static void window_choose_default_callback(struct window_choose_data *);
34: static struct window_choose_mode_item *window_choose_get_item(
35: struct window_pane *, key_code, struct mouse_event *);
36:
37: static void window_choose_fire_callback(struct window_pane *,
38: struct window_choose_data *);
39: static void window_choose_redraw_screen(struct window_pane *);
40: static void window_choose_write_line(struct window_pane *,
41: struct screen_write_ctx *, u_int);
42:
43: static void window_choose_scroll_up(struct window_pane *);
44: static void window_choose_scroll_down(struct window_pane *);
45:
46: static void window_choose_collapse(struct window_pane *, struct session *,
47: u_int);
48: static void window_choose_expand(struct window_pane *, struct session *,
49: u_int);
50: static void window_choose_collapse_all(struct window_pane *);
1.1 nicm 51:
1.79 nicm 52: static void window_choose_data_free(struct window_choose_data *);
1.27 nicm 53:
1.22 nicm 54: enum window_choose_input_type {
55: WINDOW_CHOOSE_NORMAL = -1,
56: WINDOW_CHOOSE_GOTO_ITEM,
57: };
58:
1.1 nicm 59: const struct window_mode window_choose_mode = {
1.78 nicm 60: .init = window_choose_init,
61: .free = window_choose_free,
62: .resize = window_choose_resize,
63: .key = window_choose_key,
1.64 nicm 64: };
65:
66: struct window_choose_mode_item {
67: struct window_choose_data *wcd;
68: char *name;
69: int pos;
70: int state;
71: #define TREE_EXPANDED 0x1
1.1 nicm 72: };
73:
74: struct window_choose_mode_data {
75: struct screen screen;
76:
1.75 nicm 77: struct window_choose_mode_item *list;
78: u_int list_size;
79: struct window_choose_mode_item *old_list;
80: u_int old_list_size;
81:
1.22 nicm 82: int width;
1.1 nicm 83: u_int top;
84: u_int selected;
1.22 nicm 85: enum window_choose_input_type input_type;
86: const char *input_prompt;
87: char *input_str;
1.1 nicm 88:
1.19 nicm 89: void (*callbackfn)(struct window_choose_data *);
1.1 nicm 90: };
91:
1.85 nicm 92: static const char window_choose_keys_emacs[] = "0123456789"
93: "abcdefghijklmnoprstuvwxyz"
94: "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
95: static const char window_choose_keys_vi[] = "0123456789"
1.88 nicm 96: "abcdefimnoprstuvwxyz"
1.85 nicm 97: "ABCDEFIJKMNOPQRSTUVWXYZ";
98:
1.79 nicm 99: static void window_choose_free1(struct window_choose_mode_data *);
1.85 nicm 100: static int window_choose_key_index(struct window_pane *, u_int);
101: static int window_choose_index_key(struct window_pane *, key_code);
1.79 nicm 102: static void window_choose_prompt_input(enum window_choose_input_type,
103: const char *, struct window_pane *, key_code);
104: static void window_choose_reset_top(struct window_pane *, u_int);
1.11 nicm 105:
1.1 nicm 106: void
1.19 nicm 107: window_choose_add(struct window_pane *wp, struct window_choose_data *wcd)
1.1 nicm 108: {
109: struct window_choose_mode_data *data = wp->modedata;
110: struct window_choose_mode_item *item;
1.75 nicm 111: char tmp[11];
1.1 nicm 112:
1.75 nicm 113: data->list = xreallocarray(data->list, data->list_size + 1,
114: sizeof *data->list);
115: item = &data->list[data->list_size++];
1.1 nicm 116:
1.19 nicm 117: item->name = format_expand(wcd->ft, wcd->ft_template);
118: item->wcd = wcd;
1.75 nicm 119: item->pos = data->list_size - 1;
1.27 nicm 120: item->state = 0;
1.22 nicm 121:
1.75 nicm 122: data->width = xsnprintf(tmp, sizeof tmp, "%d", item->pos);
1.1 nicm 123: }
124:
125: void
1.47 nicm 126: window_choose_set_current(struct window_pane *wp, u_int cur)
1.1 nicm 127: {
128: struct window_choose_mode_data *data = wp->modedata;
129: struct screen *s = &data->screen;
130:
131: data->selected = cur;
1.48 nicm 132: window_choose_reset_top(wp, screen_size_y(s));
133: }
134:
1.79 nicm 135: static void
1.48 nicm 136: window_choose_reset_top(struct window_pane *wp, u_int sy)
137: {
138: struct window_choose_mode_data *data = wp->modedata;
139:
140: data->top = 0;
141: if (data->selected > sy - 1)
142: data->top = data->selected - (sy - 1);
1.1 nicm 143:
1.47 nicm 144: window_choose_redraw_screen(wp);
145: }
146:
147: void
148: window_choose_ready(struct window_pane *wp, u_int cur,
149: void (*callbackfn)(struct window_choose_data *))
150: {
151: struct window_choose_mode_data *data = wp->modedata;
1.75 nicm 152: u_int size;
1.47 nicm 153:
1.3 nicm 154: data->callbackfn = callbackfn;
1.33 nicm 155: if (data->callbackfn == NULL)
156: data->callbackfn = window_choose_default_callback;
1.1 nicm 157:
1.75 nicm 158: size = data->old_list_size;
159: data->old_list_size += data->list_size;
160: data->old_list = xreallocarray(data->old_list, data->old_list_size,
161: sizeof *data->old_list);
162: memcpy(data->old_list + size, data->list, data->list_size *
163: sizeof *data->list);
1.27 nicm 164:
1.47 nicm 165: window_choose_set_current(wp, cur);
1.27 nicm 166: window_choose_collapse_all(wp);
1.1 nicm 167: }
168:
1.79 nicm 169: static struct screen *
1.1 nicm 170: window_choose_init(struct window_pane *wp)
171: {
172: struct window_choose_mode_data *data;
173: struct screen *s;
174:
1.75 nicm 175: wp->modedata = data = xcalloc(1, sizeof *data);
1.3 nicm 176:
177: data->callbackfn = NULL;
1.22 nicm 178: data->input_type = WINDOW_CHOOSE_NORMAL;
179: data->input_str = xstrdup("");
180: data->input_prompt = NULL;
1.3 nicm 181:
1.75 nicm 182: data->list = NULL;
183: data->list_size = 0;
184:
185: data->old_list = NULL;
186: data->old_list_size = 0;
187:
1.1 nicm 188: data->top = 0;
189:
190: s = &data->screen;
191: screen_init(s, screen_size_x(&wp->base), screen_size_y(&wp->base), 0);
192: s->mode &= ~MODE_CURSOR;
193:
194: return (s);
195: }
196:
1.19 nicm 197: struct window_choose_data *
1.33 nicm 198: window_choose_data_create(int type, struct client *c, struct session *s)
1.19 nicm 199: {
200: struct window_choose_data *wcd;
201:
202: wcd = xmalloc(sizeof *wcd);
1.33 nicm 203: wcd->type = type;
204:
1.90 ! nicm 205: wcd->ft = format_create(c, NULL, FORMAT_NONE, 0);
1.19 nicm 206: wcd->ft_template = NULL;
1.33 nicm 207:
1.20 nicm 208: wcd->command = NULL;
1.33 nicm 209:
1.24 nicm 210: wcd->wl = NULL;
1.33 nicm 211: wcd->pane_id = -1;
212: wcd->idx = -1;
213:
1.27 nicm 214: wcd->tree_session = NULL;
1.33 nicm 215:
216: wcd->start_client = c;
217: wcd->start_client->references++;
218: wcd->start_session = s;
219: wcd->start_session->references++;
1.19 nicm 220:
221: return (wcd);
222: }
223:
1.79 nicm 224: static void
1.33 nicm 225: window_choose_data_free(struct window_choose_data *wcd)
226: {
1.65 nicm 227: server_client_unref(wcd->start_client);
1.89 nicm 228: session_remove_ref(wcd->start_session, __func__);
1.33 nicm 229:
230: if (wcd->tree_session != NULL)
1.89 nicm 231: session_remove_ref(wcd->tree_session, __func__);
1.33 nicm 232:
233: free(wcd->ft_template);
234: format_free(wcd->ft);
235:
236: free(wcd->command);
237: free(wcd);
238: }
239:
240: void
241: window_choose_data_run(struct window_choose_data *cdata)
242: {
1.82 nicm 243: struct cmd_list *cmdlist;
244: char *cause;
245: struct cmdq_item *item;
1.33 nicm 246:
247: /*
248: * The command template will have already been replaced. But if it's
249: * NULL, bail here.
250: */
251: if (cdata->command == NULL)
252: return;
253:
1.84 nicm 254: cmdlist = cmd_string_parse(cdata->command, NULL, 0, &cause);
255: if (cmdlist == NULL) {
1.33 nicm 256: if (cause != NULL) {
257: *cause = toupper((u_char) *cause);
258: status_message_set(cdata->start_client, "%s", cause);
259: free(cause);
260: }
261: return;
262: }
263:
1.82 nicm 264: item = cmdq_get_command(cmdlist, NULL, NULL, 0);
265: cmdq_append(cdata->start_client, item);
1.33 nicm 266: cmd_list_free(cmdlist);
267: }
268:
1.79 nicm 269: static void
1.33 nicm 270: window_choose_default_callback(struct window_choose_data *wcd)
271: {
272: if (wcd == NULL)
273: return;
274: if (wcd->start_client->flags & CLIENT_DEAD)
275: return;
276:
277: window_choose_data_run(wcd);
278: }
279:
1.79 nicm 280: static void
1.1 nicm 281: window_choose_free(struct window_pane *wp)
282: {
1.38 nicm 283: if (wp->modedata != NULL)
284: window_choose_free1(wp->modedata);
285: }
286:
1.79 nicm 287: static void
1.38 nicm 288: window_choose_free1(struct window_choose_mode_data *data)
289: {
1.19 nicm 290: struct window_choose_mode_item *item;
1.1 nicm 291: u_int i;
292:
1.38 nicm 293: if (data == NULL)
294: return;
295:
1.75 nicm 296: for (i = 0; i < data->old_list_size; i++) {
297: item = &data->old_list[i];
1.33 nicm 298: window_choose_data_free(item->wcd);
1.21 nicm 299: free(item->name);
1.19 nicm 300: }
1.75 nicm 301: free(data->list);
302: free(data->old_list);
303:
1.22 nicm 304: free(data->input_str);
1.1 nicm 305:
306: screen_free(&data->screen);
1.21 nicm 307: free(data);
1.1 nicm 308: }
309:
1.79 nicm 310: static void
1.1 nicm 311: window_choose_resize(struct window_pane *wp, u_int sx, u_int sy)
312: {
313: struct window_choose_mode_data *data = wp->modedata;
314: struct screen *s = &data->screen;
315:
1.48 nicm 316: window_choose_reset_top(wp, sy);
1.32 nicm 317: screen_resize(s, sx, sy, 0);
1.1 nicm 318: window_choose_redraw_screen(wp);
319: }
320:
1.79 nicm 321: static void
1.73 nicm 322: window_choose_fire_callback(struct window_pane *wp,
323: struct window_choose_data *wcd)
1.18 nicm 324: {
325: struct window_choose_mode_data *data = wp->modedata;
326:
1.38 nicm 327: wp->modedata = NULL;
328: window_pane_reset_mode(wp);
1.18 nicm 329:
1.19 nicm 330: data->callbackfn(wcd);
1.18 nicm 331:
1.38 nicm 332: window_choose_free1(data);
1.18 nicm 333: }
334:
1.79 nicm 335: static void
1.22 nicm 336: window_choose_prompt_input(enum window_choose_input_type input_type,
1.68 nicm 337: const char *prompt, struct window_pane *wp, key_code key)
1.22 nicm 338: {
339: struct window_choose_mode_data *data = wp->modedata;
340: size_t input_len;
341:
342: data->input_type = input_type;
343: data->input_prompt = prompt;
344: input_len = strlen(data->input_str) + 2;
345:
1.55 nicm 346: data->input_str = xrealloc(data->input_str, input_len);
1.22 nicm 347: data->input_str[input_len - 2] = key;
348: data->input_str[input_len - 1] = '\0';
349:
350: window_choose_redraw_screen(wp);
351: }
352:
1.79 nicm 353: static void
1.61 nicm 354: window_choose_collapse(struct window_pane *wp, struct session *s, u_int pos)
1.27 nicm 355: {
356: struct window_choose_mode_data *data = wp->modedata;
1.75 nicm 357: struct window_choose_mode_item *item, *chosen, *copy = NULL;
1.27 nicm 358: struct window_choose_data *wcd;
1.75 nicm 359: u_int i, copy_size = 0;
1.27 nicm 360:
1.75 nicm 361: chosen = &data->list[pos];
1.27 nicm 362: chosen->state &= ~TREE_EXPANDED;
363:
364: /*
365: * Trying to mangle the &data->list in-place has lots of problems, so
366: * assign the actual result we want to render and copy the new one over
367: * the top of it.
368: */
1.75 nicm 369: for (i = 0; i < data->list_size; i++) {
370: item = &data->list[i];
1.27 nicm 371: wcd = item->wcd;
372:
373: if (s == wcd->tree_session) {
374: /* We only show the session when collapsed. */
375: if (wcd->type & TREE_SESSION) {
376: item->state &= ~TREE_EXPANDED;
1.75 nicm 377:
378: copy = xreallocarray(copy, copy_size + 1,
379: sizeof *copy);
380: memcpy(©[copy_size], item, sizeof *copy);
381: copy_size++;
1.27 nicm 382:
383: /*
384: * Update the selection to this session item so
385: * we don't end up highlighting a non-existent
386: * item.
387: */
388: data->selected = i;
389: }
1.75 nicm 390: } else {
391: copy = xreallocarray(copy, copy_size + 1, sizeof *copy);
392: memcpy(©[copy_size], item, sizeof *copy);
393: copy_size++;
394: }
1.27 nicm 395: }
396:
1.75 nicm 397: if (copy_size != 0) {
398: free(data->list);
399: data->list = copy;
400: data->list_size = copy_size;
1.27 nicm 401: }
402: }
403:
1.79 nicm 404: static void
1.27 nicm 405: window_choose_collapse_all(struct window_pane *wp)
406: {
407: struct window_choose_mode_data *data = wp->modedata;
1.28 nicm 408: struct window_choose_mode_item *item;
1.48 nicm 409: struct screen *scr = &data->screen;
1.28 nicm 410: struct session *s, *chosen;
1.27 nicm 411: u_int i;
412:
1.75 nicm 413: chosen = data->list[data->selected].wcd->start_session;
1.27 nicm 414:
415: RB_FOREACH(s, sessions, &sessions)
1.61 nicm 416: window_choose_collapse(wp, s, data->selected);
1.27 nicm 417:
418: /* Reset the selection back to the starting session. */
1.75 nicm 419: for (i = 0; i < data->list_size; i++) {
420: item = &data->list[i];
1.27 nicm 421:
1.28 nicm 422: if (chosen != item->wcd->tree_session)
1.27 nicm 423: continue;
424:
425: if (item->wcd->type & TREE_SESSION)
426: data->selected = i;
427: }
1.48 nicm 428: window_choose_reset_top(wp, screen_size_y(scr));
1.27 nicm 429: }
430:
431: void
432: window_choose_expand_all(struct window_pane *wp)
433: {
434: struct window_choose_mode_data *data = wp->modedata;
435: struct window_choose_mode_item *item;
1.48 nicm 436: struct screen *scr = &data->screen;
1.27 nicm 437: struct session *s;
438: u_int i;
439:
440: RB_FOREACH(s, sessions, &sessions) {
1.75 nicm 441: for (i = 0; i < data->list_size; i++) {
442: item = &data->list[i];
1.27 nicm 443:
444: if (s != item->wcd->tree_session)
445: continue;
446:
447: if (item->wcd->type & TREE_SESSION)
448: window_choose_expand(wp, s, i);
449: }
450: }
451:
1.48 nicm 452: window_choose_reset_top(wp, screen_size_y(scr));
1.27 nicm 453: }
454:
1.79 nicm 455: static void
1.27 nicm 456: window_choose_expand(struct window_pane *wp, struct session *s, u_int pos)
457: {
458: struct window_choose_mode_data *data = wp->modedata;
459: struct window_choose_mode_item *item, *chosen;
460: struct window_choose_data *wcd;
461: u_int i, items;
462:
1.75 nicm 463: chosen = &data->list[pos];
464: items = data->old_list_size - 1;
1.27 nicm 465:
466: /* It's not possible to expand anything other than sessions. */
467: if (!(chosen->wcd->type & TREE_SESSION))
468: return;
469:
470: /* Don't re-expand a session which is already expanded. */
471: if (chosen->state & TREE_EXPANDED)
472: return;
473:
474: /* Mark the session entry as expanded. */
475: chosen->state |= TREE_EXPANDED;
476:
477: /*
478: * Go back through the original list of all sessions and windows, and
479: * pull out the windows where the session matches the selection chosen
480: * to expand.
481: */
482: for (i = items; i > 0; i--) {
1.75 nicm 483: item = &data->old_list[i];
1.27 nicm 484: item->state |= TREE_EXPANDED;
485: wcd = item->wcd;
486:
487: if (s == wcd->tree_session) {
488: /*
489: * Since the session is already displayed, we only care
490: * to add back in window for it.
491: */
492: if (wcd->type & TREE_WINDOW) {
493: /*
494: * If the insertion point for adding the
495: * windows to the session falls inside the
496: * range of the list, then we insert these
497: * entries in order *AFTER* the selected
498: * session.
499: */
1.75 nicm 500: if (pos < i) {
501: data->list = xreallocarray(data->list,
502: data->list_size + 1,
503: sizeof *data->list);
504: memmove(&data->list[pos + 2],
505: &data->list[pos + 1],
1.76 nicm 506: (data->list_size - (pos + 1)) *
1.75 nicm 507: sizeof *data->list);
508: memcpy(&data->list[pos + 1],
509: &data->old_list[i],
510: sizeof *data->list);
511: data->list_size++;
1.27 nicm 512: } else {
513: /* Ran out of room, add to the end. */
1.75 nicm 514: data->list = xreallocarray(data->list,
515: data->list_size + 1,
516: sizeof *data->list);
517: memcpy(&data->list[data->list_size],
518: &data->old_list[i],
519: sizeof *data->list);
520: data->list_size++;
1.27 nicm 521: }
522: }
523: }
524: }
525: }
526:
1.79 nicm 527: static struct window_choose_mode_item *
1.68 nicm 528: window_choose_get_item(struct window_pane *wp, key_code key,
529: struct mouse_event *m)
1.61 nicm 530: {
531: struct window_choose_mode_data *data = wp->modedata;
532: u_int x, y, idx;
533:
534: if (!KEYC_IS_MOUSE(key))
1.75 nicm 535: return (&data->list[data->selected]);
1.61 nicm 536:
537: if (cmd_mouse_at(wp, m, &x, &y, 0) != 0)
538: return (NULL);
539:
540: idx = data->top + y;
1.75 nicm 541: if (idx >= data->list_size)
1.61 nicm 542: return (NULL);
1.75 nicm 543: return (&data->list[idx]);
1.61 nicm 544: }
545:
1.85 nicm 546: static key_code
547: window_choose_translate_key(key_code key)
548: {
549: switch (key) {
550: case '0'|KEYC_ESCAPE:
551: case '1'|KEYC_ESCAPE:
552: case '2'|KEYC_ESCAPE:
553: case '3'|KEYC_ESCAPE:
554: case '4'|KEYC_ESCAPE:
555: case '5'|KEYC_ESCAPE:
556: case '6'|KEYC_ESCAPE:
557: case '7'|KEYC_ESCAPE:
558: case '8'|KEYC_ESCAPE:
559: case '9'|KEYC_ESCAPE:
560: case '\003': /* C-c */
561: case 'q':
562: case '\n':
563: case '\r':
564: case KEYC_BSPACE:
565: case ' ':
566: case KEYC_LEFT|KEYC_CTRL:
567: case KEYC_RIGHT|KEYC_CTRL:
568: case KEYC_MOUSEDOWN1_PANE:
569: case KEYC_MOUSEDOWN3_PANE:
570: case KEYC_WHEELUP_PANE:
571: case KEYC_WHEELDOWN_PANE:
572: return (key);
573: case '\031': /* C-y */
574: case KEYC_UP|KEYC_CTRL:
575: return (KEYC_UP|KEYC_CTRL);
576: case '\002': /* C-b */
577: case KEYC_PPAGE:
578: return (KEYC_PPAGE);
579: case '\005': /* C-e */
580: case KEYC_DOWN|KEYC_CTRL:
581: return (KEYC_DOWN|KEYC_CTRL);
582: case '\006': /* C-f */
583: case KEYC_NPAGE:
584: return (KEYC_NPAGE);
1.88 nicm 585: case 'h':
586: case KEYC_LEFT:
587: return (KEYC_LEFT);
1.85 nicm 588: case 'j':
589: case KEYC_DOWN:
590: return (KEYC_DOWN);
591: case 'k':
592: case KEYC_UP:
593: return (KEYC_UP);
1.88 nicm 594: case 'l':
595: case KEYC_RIGHT:
596: return (KEYC_RIGHT);
1.85 nicm 597: case 'g':
598: case KEYC_HOME:
599: return (KEYC_HOME);
600: case 'G':
601: case KEYC_END:
602: return (KEYC_END);
603: case 'H':
604: return ('R'|KEYC_ESCAPE);
605: case 'L':
606: return ('r'|KEYC_ESCAPE);
607: }
608: if ((key >= '0' && key <= '9') ||
609: (key >= 'a' && key <= 'z') ||
610: (key >= 'A' && key <= 'Z'))
611: return (key);
612: return (KEYC_NONE);
613: }
614:
1.79 nicm 615: static void
1.70 nicm 616: window_choose_key(struct window_pane *wp, __unused struct client *c,
1.85 nicm 617: __unused struct session *sp, key_code key, struct mouse_event *m)
1.1 nicm 618: {
619: struct window_choose_mode_data *data = wp->modedata;
620: struct screen *s = &data->screen;
621: struct screen_write_ctx ctx;
622: struct window_choose_mode_item *item;
1.22 nicm 623: size_t input_len;
1.27 nicm 624: u_int items, n;
1.85 nicm 625: int idx, keys;
1.1 nicm 626:
1.85 nicm 627: keys = options_get_number(wp->window->options, "mode-keys");
628: if (keys == MODEKEY_VI) {
629: key = window_choose_translate_key(key);
630: if (key == KEYC_NONE)
631: return;
632: }
1.75 nicm 633: items = data->list_size;
1.1 nicm 634:
1.25 nicm 635: if (data->input_type == WINDOW_CHOOSE_GOTO_ITEM) {
1.85 nicm 636: switch (key) {
637: case '\003': /* C-c */
638: case '\033': /* Escape */
639: case 'q':
1.25 nicm 640: data->input_type = WINDOW_CHOOSE_NORMAL;
641: window_choose_redraw_screen(wp);
1.22 nicm 642: break;
1.85 nicm 643: case '\n':
644: case '\r':
1.22 nicm 645: n = strtonum(data->input_str, 0, INT_MAX, NULL);
1.25 nicm 646: if (n > items - 1) {
647: data->input_type = WINDOW_CHOOSE_NORMAL;
648: window_choose_redraw_screen(wp);
1.22 nicm 649: break;
1.25 nicm 650: }
1.75 nicm 651: window_choose_fire_callback(wp, data->list[n].wcd);
1.22 nicm 652: break;
1.85 nicm 653: case KEYC_BSPACE:
1.25 nicm 654: input_len = strlen(data->input_str);
655: if (input_len > 0)
656: data->input_str[input_len - 1] = '\0';
657: window_choose_redraw_screen(wp);
658: break;
659: default:
660: if (key < '0' || key > '9')
661: break;
662: window_choose_prompt_input(WINDOW_CHOOSE_GOTO_ITEM,
663: "Goto Item", wp, key);
664: break;
1.22 nicm 665: }
1.25 nicm 666: return;
667: }
668:
1.85 nicm 669: switch (key) {
670: case '\003': /* C-c */
671: case '\033': /* Escape */
672: case 'q':
1.25 nicm 673: window_choose_fire_callback(wp, NULL);
674: break;
1.85 nicm 675: case '\n':
676: case '\r':
677: case KEYC_MOUSEDOWN1_PANE:
1.61 nicm 678: if ((item = window_choose_get_item(wp, key, m)) == NULL)
679: break;
1.25 nicm 680: window_choose_fire_callback(wp, item->wcd);
1.1 nicm 681: break;
1.85 nicm 682: case ' ':
683: case KEYC_MOUSEDOWN3_PANE:
1.61 nicm 684: if ((item = window_choose_get_item(wp, key, m)) == NULL)
685: break;
686: if (item->state & TREE_EXPANDED) {
687: window_choose_collapse(wp, item->wcd->tree_session,
1.62 nicm 688: data->selected);
1.61 nicm 689: } else {
1.27 nicm 690: window_choose_expand(wp, item->wcd->tree_session,
1.62 nicm 691: data->selected);
1.27 nicm 692: }
693: window_choose_redraw_screen(wp);
694: break;
1.85 nicm 695: case KEYC_LEFT:
1.61 nicm 696: if ((item = window_choose_get_item(wp, key, m)) == NULL)
697: break;
1.27 nicm 698: if (item->state & TREE_EXPANDED) {
1.61 nicm 699: window_choose_collapse(wp, item->wcd->tree_session,
700: data->selected);
1.27 nicm 701: window_choose_redraw_screen(wp);
702: }
703: break;
1.85 nicm 704: case KEYC_LEFT|KEYC_CTRL:
1.27 nicm 705: window_choose_collapse_all(wp);
706: break;
1.85 nicm 707: case KEYC_RIGHT:
1.61 nicm 708: if ((item = window_choose_get_item(wp, key, m)) == NULL)
709: break;
1.27 nicm 710: if (!(item->state & TREE_EXPANDED)) {
711: window_choose_expand(wp, item->wcd->tree_session,
712: data->selected);
713: window_choose_redraw_screen(wp);
714: }
715: break;
1.85 nicm 716: case KEYC_RIGHT|KEYC_CTRL:
1.27 nicm 717: window_choose_expand_all(wp);
718: break;
1.85 nicm 719: case '\020': /* C-p */
720: case KEYC_UP:
721: case KEYC_WHEELUP_PANE:
1.1 nicm 722: if (items == 0)
723: break;
724: if (data->selected == 0) {
725: data->selected = items - 1;
726: if (data->selected > screen_size_y(s) - 1)
727: data->top = items - screen_size_y(s);
728: window_choose_redraw_screen(wp);
729: break;
730: }
731: data->selected--;
732: if (data->selected < data->top)
733: window_choose_scroll_up(wp);
734: else {
735: screen_write_start(&ctx, wp, NULL);
1.73 nicm 736: window_choose_write_line(wp, &ctx,
737: data->selected - data->top);
738: window_choose_write_line(wp, &ctx,
739: data->selected + 1 - data->top);
1.1 nicm 740: screen_write_stop(&ctx);
741: }
742: break;
1.85 nicm 743: case '\016': /* C-n */
744: case KEYC_DOWN:
745: case KEYC_WHEELDOWN_PANE:
1.1 nicm 746: if (items == 0)
747: break;
748: if (data->selected == items - 1) {
749: data->selected = 0;
750: data->top = 0;
751: window_choose_redraw_screen(wp);
752: break;
753: }
754: data->selected++;
1.5 nicm 755:
1.15 nicm 756: if (data->selected < data->top + screen_size_y(s)) {
1.1 nicm 757: screen_write_start(&ctx, wp, NULL);
1.73 nicm 758: window_choose_write_line(wp, &ctx,
759: data->selected - data->top);
760: window_choose_write_line(wp, &ctx,
761: data->selected - 1 - data->top);
1.1 nicm 762: screen_write_stop(&ctx);
1.15 nicm 763: } else
764: window_choose_scroll_down(wp);
765: break;
1.85 nicm 766: case KEYC_UP|KEYC_CTRL:
1.15 nicm 767: if (items == 0 || data->top == 0)
768: break;
769: if (data->selected == data->top + screen_size_y(s) - 1) {
770: data->selected--;
771: window_choose_scroll_up(wp);
772: screen_write_start(&ctx, wp, NULL);
1.73 nicm 773: window_choose_write_line(wp, &ctx,
774: screen_size_y(s) - 1);
1.15 nicm 775: screen_write_stop(&ctx);
776: } else
777: window_choose_scroll_up(wp);
778: break;
1.85 nicm 779: case KEYC_DOWN|KEYC_CTRL:
1.15 nicm 780: if (items == 0 ||
781: data->top + screen_size_y(&data->screen) >= items)
782: break;
783: if (data->selected == data->top) {
784: data->selected++;
785: window_choose_scroll_down(wp);
786: screen_write_start(&ctx, wp, NULL);
787: window_choose_write_line(wp, &ctx, 0);
788: screen_write_stop(&ctx);
789: } else
790: window_choose_scroll_down(wp);
1.1 nicm 791: break;
1.85 nicm 792: case KEYC_PPAGE:
1.1 nicm 793: if (data->selected < screen_size_y(s)) {
794: data->selected = 0;
795: data->top = 0;
796: } else {
797: data->selected -= screen_size_y(s);
798: if (data->top < screen_size_y(s))
799: data->top = 0;
800: else
801: data->top -= screen_size_y(s);
802: }
1.13 nicm 803: window_choose_redraw_screen(wp);
1.1 nicm 804: break;
1.85 nicm 805: case KEYC_NPAGE:
1.1 nicm 806: data->selected += screen_size_y(s);
807: if (data->selected > items - 1)
808: data->selected = items - 1;
809: data->top += screen_size_y(s);
810: if (screen_size_y(s) < items) {
811: if (data->top + screen_size_y(s) > items)
812: data->top = items - screen_size_y(s);
813: } else
814: data->top = 0;
815: if (data->selected < data->top)
816: data->top = data->selected;
817: window_choose_redraw_screen(wp);
818: break;
1.85 nicm 819: case KEYC_BSPACE:
1.22 nicm 820: input_len = strlen(data->input_str);
821: if (input_len > 0)
822: data->input_str[input_len - 1] = '\0';
823: window_choose_redraw_screen(wp);
824: break;
1.85 nicm 825: case '0'|KEYC_ESCAPE:
826: case '1'|KEYC_ESCAPE:
827: case '2'|KEYC_ESCAPE:
828: case '3'|KEYC_ESCAPE:
829: case '4'|KEYC_ESCAPE:
830: case '5'|KEYC_ESCAPE:
831: case '6'|KEYC_ESCAPE:
832: case '7'|KEYC_ESCAPE:
833: case '8'|KEYC_ESCAPE:
834: case '9'|KEYC_ESCAPE:
1.25 nicm 835: key &= KEYC_MASK_KEY;
836: if (key < '0' || key > '9')
1.11 nicm 837: break;
1.25 nicm 838: window_choose_prompt_input(WINDOW_CHOOSE_GOTO_ITEM,
839: "Goto Item", wp, key);
1.51 nicm 840: break;
1.85 nicm 841: case KEYC_HOME:
842: case '<'|KEYC_ESCAPE:
1.51 nicm 843: data->selected = 0;
844: data->top = 0;
845: window_choose_redraw_screen(wp);
846: break;
1.85 nicm 847: case 'R'|KEYC_ESCAPE:
1.51 nicm 848: data->selected = data->top;
849: window_choose_redraw_screen(wp);
850: break;
1.85 nicm 851: case 'r'|KEYC_ESCAPE:
1.51 nicm 852: data->selected = data->top + screen_size_y(s) - 1;
853: if (data->selected > items - 1)
854: data->selected = items - 1;
855: window_choose_redraw_screen(wp);
856: break;
1.85 nicm 857: case KEYC_END:
858: case '>'|KEYC_ESCAPE:
1.51 nicm 859: data->selected = items - 1;
860: if (screen_size_y(s) < items)
861: data->top = items - screen_size_y(s);
862: else
863: data->top = 0;
864: window_choose_redraw_screen(wp);
1.22 nicm 865: break;
866: default:
1.85 nicm 867: idx = window_choose_index_key(wp, key);
1.75 nicm 868: if (idx < 0 || (u_int) idx >= data->list_size)
1.25 nicm 869: break;
870: data->selected = idx;
1.75 nicm 871: window_choose_fire_callback(wp, data->list[idx].wcd);
1.1 nicm 872: break;
873: }
874: }
875:
1.79 nicm 876: static void
1.68 nicm 877: window_choose_write_line(struct window_pane *wp, struct screen_write_ctx *ctx,
878: u_int py)
1.1 nicm 879: {
880: struct window_choose_mode_data *data = wp->modedata;
881: struct window_choose_mode_item *item;
1.67 nicm 882: struct options *oo = wp->window->options;
1.1 nicm 883: struct screen *s = &data->screen;
884: struct grid_cell gc;
1.22 nicm 885: size_t last, xoff = 0;
1.25 nicm 886: char hdr[32], label[32];
1.69 nicm 887: int key;
1.1 nicm 888:
1.3 nicm 889: if (data->callbackfn == NULL)
1.1 nicm 890: fatalx("called before callback assigned");
891:
1.22 nicm 892: last = screen_size_y(s) - 1;
1.1 nicm 893: memcpy(&gc, &grid_default_cell, sizeof gc);
1.83 nicm 894: gc.flags |= GRID_FLAG_NOPALETTE;
1.22 nicm 895: if (data->selected == data->top + py)
1.50 nicm 896: style_apply(&gc, oo, "mode-style");
1.1 nicm 897:
898: screen_write_cursormove(ctx, 0, py);
1.75 nicm 899: if (data->top + py < data->list_size) {
900: item = &data->list[data->top + py];
1.24 nicm 901: if (item->wcd->wl != NULL &&
902: item->wcd->wl->flags & WINLINK_ALERTFLAGS)
903: gc.attr |= GRID_ATTR_BRIGHT;
1.11 nicm 904:
1.85 nicm 905: key = window_choose_key_index(wp, data->top + py);
1.25 nicm 906: if (key != -1)
1.56 nicm 907: xsnprintf(label, sizeof label, "(%c)", key);
1.25 nicm 908: else
1.56 nicm 909: xsnprintf(label, sizeof label, "(%d)", item->pos);
1.69 nicm 910: screen_write_nputs(ctx, screen_size_x(s) - 1, &gc,
1.27 nicm 911: "%*s %s %s", data->width + 2, label,
912: /*
913: * Add indication to tree if necessary about whether it's
914: * expanded or not.
915: */
916: (item->wcd->type & TREE_SESSION) ?
1.87 nicm 917: ((item->state & TREE_EXPANDED) ? "-" : "+") : "", item->name);
1.1 nicm 918: }
1.40 nicm 919: while (s->cx < screen_size_x(s) - 1)
1.1 nicm 920: screen_write_putc(ctx, &gc, ' ');
1.11 nicm 921:
1.22 nicm 922: if (data->input_type != WINDOW_CHOOSE_NORMAL) {
1.50 nicm 923: style_apply(&gc, oo, "mode-style");
1.11 nicm 924:
1.22 nicm 925: xoff = xsnprintf(hdr, sizeof hdr,
926: "%s: %s", data->input_prompt, data->input_str);
927: screen_write_cursormove(ctx, 0, last);
928: screen_write_puts(ctx, &gc, "%s", hdr);
929: screen_write_cursormove(ctx, xoff, py);
930: memcpy(&gc, &grid_default_cell, sizeof gc);
1.11 nicm 931: }
1.22 nicm 932:
1.11 nicm 933: }
934:
1.79 nicm 935: static int
1.85 nicm 936: window_choose_key_index(struct window_pane *wp, u_int idx)
1.25 nicm 937: {
1.85 nicm 938: const char *ptr;
939: int keys;
940:
941: keys = options_get_number(wp->window->options, "mode-keys");
942: if (keys == MODEKEY_VI)
943: ptr = window_choose_keys_vi;
944: else
945: ptr = window_choose_keys_emacs;
946: for (; *ptr != '\0'; ptr++) {
1.25 nicm 947: if (idx-- == 0)
948: return (*ptr);
949: }
950: return (-1);
951: }
952:
1.79 nicm 953: static int
1.85 nicm 954: window_choose_index_key(struct window_pane *wp, key_code key)
1.11 nicm 955: {
1.85 nicm 956: const char *ptr;
957: int keys;
958: u_int idx = 0;
959:
960: keys = options_get_number(wp->window->options, "mode-keys");
961: if (keys == MODEKEY_VI)
962: ptr = window_choose_keys_vi;
963: else
964: ptr = window_choose_keys_emacs;
965: for (; *ptr != '\0'; ptr++) {
1.68 nicm 966: if (key == (key_code)*ptr)
1.11 nicm 967: return (idx);
968: idx++;
969: }
970: return (-1);
1.1 nicm 971: }
972:
1.79 nicm 973: static void
1.1 nicm 974: window_choose_redraw_screen(struct window_pane *wp)
975: {
976: struct window_choose_mode_data *data = wp->modedata;
977: struct screen *s = &data->screen;
978: struct screen_write_ctx ctx;
979: u_int i;
980:
981: screen_write_start(&ctx, wp, NULL);
982: for (i = 0; i < screen_size_y(s); i++)
983: window_choose_write_line(wp, &ctx, i);
984: screen_write_stop(&ctx);
985: }
986:
1.79 nicm 987: static void
1.1 nicm 988: window_choose_scroll_up(struct window_pane *wp)
989: {
990: struct window_choose_mode_data *data = wp->modedata;
991: struct screen_write_ctx ctx;
992:
993: if (data->top == 0)
994: return;
995: data->top--;
996:
997: screen_write_start(&ctx, wp, NULL);
998: screen_write_cursormove(&ctx, 0, 0);
1.80 nicm 999: screen_write_insertline(&ctx, 1, 8);
1.1 nicm 1000: window_choose_write_line(wp, &ctx, 0);
1001: if (screen_size_y(&data->screen) > 1)
1002: window_choose_write_line(wp, &ctx, 1);
1003: screen_write_stop(&ctx);
1004: }
1005:
1.79 nicm 1006: static void
1.1 nicm 1007: window_choose_scroll_down(struct window_pane *wp)
1008: {
1009: struct window_choose_mode_data *data = wp->modedata;
1010: struct screen *s = &data->screen;
1011: struct screen_write_ctx ctx;
1012:
1.75 nicm 1013: if (data->top >= data->list_size)
1.1 nicm 1014: return;
1015: data->top++;
1016:
1017: screen_write_start(&ctx, wp, NULL);
1018: screen_write_cursormove(&ctx, 0, 0);
1.80 nicm 1019: screen_write_deleteline(&ctx, 1, 8);
1.1 nicm 1020: window_choose_write_line(wp, &ctx, screen_size_y(s) - 1);
1021: if (screen_size_y(&data->screen) > 1)
1022: window_choose_write_line(wp, &ctx, screen_size_y(s) - 2);
1023: screen_write_stop(&ctx);
1.19 nicm 1024: }
1025:
1.20 nicm 1026: struct window_choose_data *
1.35 nicm 1027: window_choose_add_session(struct window_pane *wp, struct client *c,
1.36 nicm 1028: struct session *s, const char *template, const char *action, u_int idx)
1.20 nicm 1029: {
1030: struct window_choose_data *wcd;
1031:
1.33 nicm 1032: wcd = window_choose_data_create(TREE_SESSION, c, c->session);
1.46 nicm 1033: wcd->idx = s->id;
1.33 nicm 1034:
1.27 nicm 1035: wcd->tree_session = s;
1.33 nicm 1036: wcd->tree_session->references++;
1037:
1.20 nicm 1038: wcd->ft_template = xstrdup(template);
1039: format_add(wcd->ft, "line", "%u", idx);
1.59 nicm 1040: format_defaults(wcd->ft, NULL, s, NULL, NULL);
1.20 nicm 1041:
1.33 nicm 1042: wcd->command = cmd_template_replace(action, s->name, 1);
1.20 nicm 1043:
1044: window_choose_add(wp, wcd);
1045:
1046: return (wcd);
1047: }
1048:
1049: struct window_choose_data *
1.35 nicm 1050: window_choose_add_window(struct window_pane *wp, struct client *c,
1.22 nicm 1051: struct session *s, struct winlink *wl, const char *template,
1.36 nicm 1052: const char *action, u_int idx)
1.20 nicm 1053: {
1054: struct window_choose_data *wcd;
1.33 nicm 1055: char *expanded;
1.20 nicm 1056:
1.33 nicm 1057: wcd = window_choose_data_create(TREE_WINDOW, c, c->session);
1058: wcd->idx = wl->idx;
1.20 nicm 1059:
1.33 nicm 1060: wcd->wl = wl;
1.20 nicm 1061:
1.27 nicm 1062: wcd->tree_session = s;
1.33 nicm 1063: wcd->tree_session->references++;
1064:
1.20 nicm 1065: wcd->ft_template = xstrdup(template);
1066: format_add(wcd->ft, "line", "%u", idx);
1.59 nicm 1067: format_defaults(wcd->ft, NULL, s, wl, NULL);
1.20 nicm 1068:
1.33 nicm 1069: xasprintf(&expanded, "%s:%d", s->name, wl->idx);
1070: wcd->command = cmd_template_replace(action, expanded, 1);
1071: free(expanded);
1.20 nicm 1072:
1073: window_choose_add(wp, wcd);
1074:
1075: return (wcd);
1.1 nicm 1076: }
![[BACK]](/icons/back.gif){kind=icon}
Return to window-choose.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux