![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to window-choose.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux|
Return to window-choose.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux |
1.1 misho 1: /* $OpenBSD$ */
2:
3: /*
4: * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/types.h>
20:
21: #include <ctype.h>
22: #include <stdlib.h>
23: #include <string.h>
24:
25: #include "tmux.h"
26:
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 *);
51:
52: static void window_choose_data_free(struct window_choose_data *);
53:
54: enum window_choose_input_type {
55: WINDOW_CHOOSE_NORMAL = -1,
56: WINDOW_CHOOSE_GOTO_ITEM,
57: };
58:
59: const struct window_mode window_choose_mode = {
60: .init = window_choose_init,
61: .free = window_choose_free,
62: .resize = window_choose_resize,
63: .key = window_choose_key,
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
72: };
73:
74: struct window_choose_mode_data {
75: struct screen screen;
76:
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:
82: int width;
83: u_int top;
84: u_int selected;
85: enum window_choose_input_type input_type;
86: const char *input_prompt;
87: char *input_str;
88:
89: void (*callbackfn)(struct window_choose_data *);
90: };
91:
92: static const char window_choose_keys_emacs[] = "0123456789"
93: "abcdefghijklmnoprstuvwxyz"
94: "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
95: static const char window_choose_keys_vi[] = "0123456789"
96: "abcdefimnoprstuvwxyz"
97: "ABCDEFIJKMNOPQRSTUVWXYZ";
98:
99: static void window_choose_free1(struct window_choose_mode_data *);
100: static int window_choose_key_index(struct window_pane *, u_int);
101: static int window_choose_index_key(struct window_pane *, key_code);
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);
105:
106: void
107: window_choose_add(struct window_pane *wp, struct window_choose_data *wcd)
108: {
109: struct window_choose_mode_data *data = wp->modedata;
110: struct window_choose_mode_item *item;
111: char tmp[11];
112:
113: data->list = xreallocarray(data->list, data->list_size + 1,
114: sizeof *data->list);
115: item = &data->list[data->list_size++];
116:
117: item->name = format_expand(wcd->ft, wcd->ft_template);
118: item->wcd = wcd;
119: item->pos = data->list_size - 1;
120: item->state = 0;
121:
122: data->width = xsnprintf(tmp, sizeof tmp, "%d", item->pos);
123: }
124:
125: void
126: window_choose_set_current(struct window_pane *wp, u_int cur)
127: {
128: struct window_choose_mode_data *data = wp->modedata;
129: struct screen *s = &data->screen;
130:
131: data->selected = cur;
132: window_choose_reset_top(wp, screen_size_y(s));
133: }
134:
135: static void
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);
143:
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;
152: u_int size;
153:
154: data->callbackfn = callbackfn;
155: if (data->callbackfn == NULL)
156: data->callbackfn = window_choose_default_callback;
157:
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);
164:
165: window_choose_set_current(wp, cur);
166: window_choose_collapse_all(wp);
167: }
168:
169: static struct screen *
170: window_choose_init(struct window_pane *wp)
171: {
172: struct window_choose_mode_data *data;
173: struct screen *s;
174:
175: wp->modedata = data = xcalloc(1, sizeof *data);
176:
177: data->callbackfn = NULL;
178: data->input_type = WINDOW_CHOOSE_NORMAL;
179: data->input_str = xstrdup("");
180: data->input_prompt = NULL;
181:
182: data->list = NULL;
183: data->list_size = 0;
184:
185: data->old_list = NULL;
186: data->old_list_size = 0;
187:
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:
197: struct window_choose_data *
198: window_choose_data_create(int type, struct client *c, struct session *s)
199: {
200: struct window_choose_data *wcd;
201:
202: wcd = xmalloc(sizeof *wcd);
203: wcd->type = type;
204:
205: wcd->ft = format_create(NULL, FORMAT_NONE, 0);
206: wcd->ft_template = NULL;
207:
208: wcd->command = NULL;
209:
210: wcd->wl = NULL;
211: wcd->pane_id = -1;
212: wcd->idx = -1;
213:
214: wcd->tree_session = NULL;
215:
216: wcd->start_client = c;
217: wcd->start_client->references++;
218: wcd->start_session = s;
219: wcd->start_session->references++;
220:
221: return (wcd);
222: }
223:
224: static void
225: window_choose_data_free(struct window_choose_data *wcd)
226: {
227: server_client_unref(wcd->start_client);
228: session_unref(wcd->start_session);
229:
230: if (wcd->tree_session != NULL)
231: session_unref(wcd->tree_session);
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: {
243: struct cmd_list *cmdlist;
244: char *cause;
245: struct cmdq_item *item;
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:
254: cmdlist = cmd_string_parse(cdata->command, NULL, 0, &cause);
255: if (cmdlist == NULL) {
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:
264: item = cmdq_get_command(cmdlist, NULL, NULL, 0);
265: cmdq_append(cdata->start_client, item);
266: cmd_list_free(cmdlist);
267: }
268:
269: static void
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:
280: static void
281: window_choose_free(struct window_pane *wp)
282: {
283: if (wp->modedata != NULL)
284: window_choose_free1(wp->modedata);
285: }
286:
287: static void
288: window_choose_free1(struct window_choose_mode_data *data)
289: {
290: struct window_choose_mode_item *item;
291: u_int i;
292:
293: if (data == NULL)
294: return;
295:
296: for (i = 0; i < data->old_list_size; i++) {
297: item = &data->old_list[i];
298: window_choose_data_free(item->wcd);
299: free(item->name);
300: }
301: free(data->list);
302: free(data->old_list);
303:
304: free(data->input_str);
305:
306: screen_free(&data->screen);
307: free(data);
308: }
309:
310: static void
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:
316: window_choose_reset_top(wp, sy);
317: screen_resize(s, sx, sy, 0);
318: window_choose_redraw_screen(wp);
319: }
320:
321: static void
322: window_choose_fire_callback(struct window_pane *wp,
323: struct window_choose_data *wcd)
324: {
325: struct window_choose_mode_data *data = wp->modedata;
326:
327: wp->modedata = NULL;
328: window_pane_reset_mode(wp);
329:
330: data->callbackfn(wcd);
331:
332: window_choose_free1(data);
333: }
334:
335: static void
336: window_choose_prompt_input(enum window_choose_input_type input_type,
337: const char *prompt, struct window_pane *wp, key_code key)
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:
346: data->input_str = xrealloc(data->input_str, input_len);
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:
353: static void
354: window_choose_collapse(struct window_pane *wp, struct session *s, u_int pos)
355: {
356: struct window_choose_mode_data *data = wp->modedata;
357: struct window_choose_mode_item *item, *chosen, *copy = NULL;
358: struct window_choose_data *wcd;
359: u_int i, copy_size = 0;
360:
361: chosen = &data->list[pos];
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: */
369: for (i = 0; i < data->list_size; i++) {
370: item = &data->list[i];
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;
377:
378: copy = xreallocarray(copy, copy_size + 1,
379: sizeof *copy);
380: memcpy(©[copy_size], item, sizeof *copy);
381: copy_size++;
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: }
390: } else {
391: copy = xreallocarray(copy, copy_size + 1, sizeof *copy);
392: memcpy(©[copy_size], item, sizeof *copy);
393: copy_size++;
394: }
395: }
396:
397: if (copy_size != 0) {
398: free(data->list);
399: data->list = copy;
400: data->list_size = copy_size;
401: }
402: }
403:
404: static void
405: window_choose_collapse_all(struct window_pane *wp)
406: {
407: struct window_choose_mode_data *data = wp->modedata;
408: struct window_choose_mode_item *item;
409: struct screen *scr = &data->screen;
410: struct session *s, *chosen;
411: u_int i;
412:
413: chosen = data->list[data->selected].wcd->start_session;
414:
415: RB_FOREACH(s, sessions, &sessions)
416: window_choose_collapse(wp, s, data->selected);
417:
418: /* Reset the selection back to the starting session. */
419: for (i = 0; i < data->list_size; i++) {
420: item = &data->list[i];
421:
422: if (chosen != item->wcd->tree_session)
423: continue;
424:
425: if (item->wcd->type & TREE_SESSION)
426: data->selected = i;
427: }
428: window_choose_reset_top(wp, screen_size_y(scr));
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;
436: struct screen *scr = &data->screen;
437: struct session *s;
438: u_int i;
439:
440: RB_FOREACH(s, sessions, &sessions) {
441: for (i = 0; i < data->list_size; i++) {
442: item = &data->list[i];
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:
452: window_choose_reset_top(wp, screen_size_y(scr));
453: }
454:
455: static void
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:
463: chosen = &data->list[pos];
464: items = data->old_list_size - 1;
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--) {
483: item = &data->old_list[i];
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: */
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],
506: (data->list_size - (pos + 1)) *
507: sizeof *data->list);
508: memcpy(&data->list[pos + 1],
509: &data->old_list[i],
510: sizeof *data->list);
511: data->list_size++;
512: } else {
513: /* Ran out of room, add to the end. */
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++;
521: }
522: }
523: }
524: }
525: }
526:
527: static struct window_choose_mode_item *
528: window_choose_get_item(struct window_pane *wp, key_code key,
529: struct mouse_event *m)
530: {
531: struct window_choose_mode_data *data = wp->modedata;
532: u_int x, y, idx;
533:
534: if (!KEYC_IS_MOUSE(key))
535: return (&data->list[data->selected]);
536:
537: if (cmd_mouse_at(wp, m, &x, &y, 0) != 0)
538: return (NULL);
539:
540: idx = data->top + y;
541: if (idx >= data->list_size)
542: return (NULL);
543: return (&data->list[idx]);
544: }
545:
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);
585: case 'h':
586: case KEYC_LEFT:
587: return (KEYC_LEFT);
588: case 'j':
589: case KEYC_DOWN:
590: return (KEYC_DOWN);
591: case 'k':
592: case KEYC_UP:
593: return (KEYC_UP);
594: case 'l':
595: case KEYC_RIGHT:
596: return (KEYC_RIGHT);
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:
615: static void
616: window_choose_key(struct window_pane *wp, __unused struct client *c,
617: __unused struct session *sp, key_code key, struct mouse_event *m)
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;
623: size_t input_len;
624: u_int items, n;
625: int idx, keys;
626:
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: }
633: items = data->list_size;
634:
635: if (data->input_type == WINDOW_CHOOSE_GOTO_ITEM) {
636: switch (key) {
637: case '\003': /* C-c */
638: case '\033': /* Escape */
639: case 'q':
640: data->input_type = WINDOW_CHOOSE_NORMAL;
641: window_choose_redraw_screen(wp);
642: break;
643: case '\n':
644: case '\r':
645: n = strtonum(data->input_str, 0, INT_MAX, NULL);
646: if (n > items - 1) {
647: data->input_type = WINDOW_CHOOSE_NORMAL;
648: window_choose_redraw_screen(wp);
649: break;
650: }
651: window_choose_fire_callback(wp, data->list[n].wcd);
652: break;
653: case KEYC_BSPACE:
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;
665: }
666: return;
667: }
668:
669: switch (key) {
670: case '\003': /* C-c */
671: case '\033': /* Escape */
672: case 'q':
673: window_choose_fire_callback(wp, NULL);
674: break;
675: case '\n':
676: case '\r':
677: case KEYC_MOUSEDOWN1_PANE:
678: if ((item = window_choose_get_item(wp, key, m)) == NULL)
679: break;
680: window_choose_fire_callback(wp, item->wcd);
681: break;
682: case ' ':
683: case KEYC_MOUSEDOWN3_PANE:
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,
688: data->selected);
689: } else {
690: window_choose_expand(wp, item->wcd->tree_session,
691: data->selected);
692: }
693: window_choose_redraw_screen(wp);
694: break;
695: case KEYC_LEFT:
696: if ((item = window_choose_get_item(wp, key, m)) == NULL)
697: break;
698: if (item->state & TREE_EXPANDED) {
699: window_choose_collapse(wp, item->wcd->tree_session,
700: data->selected);
701: window_choose_redraw_screen(wp);
702: }
703: break;
704: case KEYC_LEFT|KEYC_CTRL:
705: window_choose_collapse_all(wp);
706: break;
707: case KEYC_RIGHT:
708: if ((item = window_choose_get_item(wp, key, m)) == NULL)
709: break;
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;
716: case KEYC_RIGHT|KEYC_CTRL:
717: window_choose_expand_all(wp);
718: break;
719: case '\020': /* C-p */
720: case KEYC_UP:
721: case KEYC_WHEELUP_PANE:
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);
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);
740: screen_write_stop(&ctx);
741: }
742: break;
743: case '\016': /* C-n */
744: case KEYC_DOWN:
745: case KEYC_WHEELDOWN_PANE:
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++;
755:
756: if (data->selected < data->top + screen_size_y(s)) {
757: screen_write_start(&ctx, wp, NULL);
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);
762: screen_write_stop(&ctx);
763: } else
764: window_choose_scroll_down(wp);
765: break;
766: case KEYC_UP|KEYC_CTRL:
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);
773: window_choose_write_line(wp, &ctx,
774: screen_size_y(s) - 1);
775: screen_write_stop(&ctx);
776: } else
777: window_choose_scroll_up(wp);
778: break;
779: case KEYC_DOWN|KEYC_CTRL:
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);
791: break;
792: case KEYC_PPAGE:
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: }
803: window_choose_redraw_screen(wp);
804: break;
805: case KEYC_NPAGE:
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;
819: case KEYC_BSPACE:
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;
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:
835: key &= KEYC_MASK_KEY;
836: if (key < '0' || key > '9')
837: break;
838: window_choose_prompt_input(WINDOW_CHOOSE_GOTO_ITEM,
839: "Goto Item", wp, key);
840: break;
841: case KEYC_HOME:
842: case '<'|KEYC_ESCAPE:
843: data->selected = 0;
844: data->top = 0;
845: window_choose_redraw_screen(wp);
846: break;
847: case 'R'|KEYC_ESCAPE:
848: data->selected = data->top;
849: window_choose_redraw_screen(wp);
850: break;
851: case 'r'|KEYC_ESCAPE:
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;
857: case KEYC_END:
858: case '>'|KEYC_ESCAPE:
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);
865: break;
866: default:
867: idx = window_choose_index_key(wp, key);
868: if (idx < 0 || (u_int) idx >= data->list_size)
869: break;
870: data->selected = idx;
871: window_choose_fire_callback(wp, data->list[idx].wcd);
872: break;
873: }
874: }
875:
876: static void
877: window_choose_write_line(struct window_pane *wp, struct screen_write_ctx *ctx,
878: u_int py)
879: {
880: struct window_choose_mode_data *data = wp->modedata;
881: struct window_choose_mode_item *item;
882: struct options *oo = wp->window->options;
883: struct screen *s = &data->screen;
884: struct grid_cell gc;
885: size_t last, xoff = 0;
886: char hdr[32], label[32];
887: int key;
888:
889: if (data->callbackfn == NULL)
890: fatalx("called before callback assigned");
891:
892: last = screen_size_y(s) - 1;
893: memcpy(&gc, &grid_default_cell, sizeof gc);
894: gc.flags |= GRID_FLAG_NOPALETTE;
895: if (data->selected == data->top + py)
896: style_apply(&gc, oo, "mode-style");
897:
898: screen_write_cursormove(ctx, 0, py);
899: if (data->top + py < data->list_size) {
900: item = &data->list[data->top + py];
901: if (item->wcd->wl != NULL &&
902: item->wcd->wl->flags & WINLINK_ALERTFLAGS)
903: gc.attr |= GRID_ATTR_BRIGHT;
904:
905: key = window_choose_key_index(wp, data->top + py);
906: if (key != -1)
907: xsnprintf(label, sizeof label, "(%c)", key);
908: else
909: xsnprintf(label, sizeof label, "(%d)", item->pos);
910: screen_write_nputs(ctx, screen_size_x(s) - 1, &gc,
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) ?
917: ((item->state & TREE_EXPANDED) ? "-" : "+") : "", item->name);
918: }
919: while (s->cx < screen_size_x(s) - 1)
920: screen_write_putc(ctx, &gc, ' ');
921:
922: if (data->input_type != WINDOW_CHOOSE_NORMAL) {
923: style_apply(&gc, oo, "mode-style");
924:
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);
931: }
932:
933: }
934:
935: static int
936: window_choose_key_index(struct window_pane *wp, u_int idx)
937: {
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++) {
947: if (idx-- == 0)
948: return (*ptr);
949: }
950: return (-1);
951: }
952:
953: static int
954: window_choose_index_key(struct window_pane *wp, key_code key)
955: {
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++) {
966: if (key == (key_code)*ptr)
967: return (idx);
968: idx++;
969: }
970: return (-1);
971: }
972:
973: static void
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:
987: static void
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);
999: screen_write_insertline(&ctx, 1, 8);
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:
1006: static void
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:
1013: if (data->top >= data->list_size)
1014: return;
1015: data->top++;
1016:
1017: screen_write_start(&ctx, wp, NULL);
1018: screen_write_cursormove(&ctx, 0, 0);
1019: screen_write_deleteline(&ctx, 1, 8);
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);
1024: }
1025:
1026: struct window_choose_data *
1027: window_choose_add_session(struct window_pane *wp, struct client *c,
1028: struct session *s, const char *template, const char *action, u_int idx)
1029: {
1030: struct window_choose_data *wcd;
1031:
1032: wcd = window_choose_data_create(TREE_SESSION, c, c->session);
1033: wcd->idx = s->id;
1034:
1035: wcd->tree_session = s;
1036: wcd->tree_session->references++;
1037:
1038: wcd->ft_template = xstrdup(template);
1039: format_add(wcd->ft, "line", "%u", idx);
1040: format_defaults(wcd->ft, NULL, s, NULL, NULL);
1041:
1042: wcd->command = cmd_template_replace(action, s->name, 1);
1043:
1044: window_choose_add(wp, wcd);
1045:
1046: return (wcd);
1047: }
1048:
1049: struct window_choose_data *
1050: window_choose_add_window(struct window_pane *wp, struct client *c,
1051: struct session *s, struct winlink *wl, const char *template,
1052: const char *action, u_int idx)
1053: {
1054: struct window_choose_data *wcd;
1055: char *expanded;
1056:
1057: wcd = window_choose_data_create(TREE_WINDOW, c, c->session);
1058: wcd->idx = wl->idx;
1059:
1060: wcd->wl = wl;
1061:
1062: wcd->tree_session = s;
1063: wcd->tree_session->references++;
1064:
1065: wcd->ft_template = xstrdup(template);
1066: format_add(wcd->ft, "line", "%u", idx);
1067: format_defaults(wcd->ft, NULL, s, wl, NULL);
1068:
1069: xasprintf(&expanded, "%s:%d", s->name, wl->idx);
1070: wcd->command = cmd_template_replace(action, expanded, 1);
1071: free(expanded);
1072:
1073: window_choose_add(wp, wcd);
1074:
1075: return (wcd);
1076: }