?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add missing -T to getopt string.
[tmux.git] / menu.c
blob8d7b40a2e390675edac041428ce391dcc4dc10f8
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2019 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 <stdlib.h>
22 #include <string.h>
23
24 #include "tmux.h"
25
26 struct menu_data {
27 struct cmdq_item *item;
28 int flags;
29
30 struct grid_cell style;
31 struct grid_cell border_style;
32 struct grid_cell selected_style;
33 enum box_lines border_lines;
34
35 struct cmd_find_state fs;
36 struct screen s;
37
38 u_int px;
39 u_int py;
40
41 struct menu *menu;
42 int choice;
43
44 menu_choice_cb cb;
45 void *data;
46 };
47
48 void
49 menu_add_items(struct menu *menu, const struct menu_item *items,
50 struct cmdq_item *qitem, struct client *c, struct cmd_find_state *fs)
51 {
52 const struct menu_item *loop;
53
54 for (loop = items; loop->name != NULL; loop++)
55 menu_add_item(menu, loop, qitem, c, fs);
56 }
57
58 void
59 menu_add_item(struct menu *menu, const struct menu_item *item,
60 struct cmdq_item *qitem, struct client *c, struct cmd_find_state *fs)
61 {
62 struct menu_item *new_item;
63 const char *key = NULL, *cmd, *suffix = "";
64 char *s, *trimmed, *name;
65 u_int width, max_width;
66 int line;
67 size_t keylen, slen;
68
69 line = (item == NULL || item->name == NULL || *item->name == '\0');
70 if (line && menu->count == 0)
71 return;
72 if (line && menu->items[menu->count - 1].name == NULL)
73 return;
74
75 menu->items = xreallocarray(menu->items, menu->count + 1,
76 sizeof *menu->items);
77 new_item = &menu->items[menu->count++];
78 memset(new_item, 0, sizeof *new_item);
79
80 if (line)
81 return;
82
83 if (fs != NULL)
84 s = format_single_from_state(qitem, item->name, c, fs);
85 else
86 s = format_single(qitem, item->name, c, NULL, NULL, NULL);
87 if (*s == '\0') { /* no item if empty after format expanded */
88 menu->count--;
89 return;
90 }
91 max_width = c->tty.sx - 4;
92
93 slen = strlen(s);
94 if (*s != '-' && item->key != KEYC_UNKNOWN && item->key != KEYC_NONE) {
95 key = key_string_lookup_key(item->key, 0);
96 keylen = strlen(key) + 3; /* 3 = space and two brackets */
97
98 /*
99 * Add the key if it is shorter than a quarter of the available
100 * space or there is space for the entire item text and the
101 * key.
102 */
103 if (keylen <= max_width / 4)
104 max_width -= keylen;
105 else if (keylen >= max_width || slen >= max_width - keylen)
106 key = NULL;
107 }
108
109 if (slen > max_width) {
110 max_width--;
111 suffix = ">";
112 }
113 trimmed = format_trim_right(s, max_width);
114 if (key != NULL) {
115 xasprintf(&name, "%s%s#[default] #[align=right](%s)",
116 trimmed, suffix, key);
117 } else
118 xasprintf(&name, "%s%s", trimmed, suffix);
119 free(trimmed);
120
121 new_item->name = name;
122 free(s);
123
124 cmd = item->command;
125 if (cmd != NULL) {
126 if (fs != NULL)
127 s = format_single_from_state(qitem, cmd, c, fs);
128 else
129 s = format_single(qitem, cmd, c, NULL, NULL, NULL);
130 } else
131 s = NULL;
132 new_item->command = s;
133 new_item->key = item->key;
134
135 width = format_width(new_item->name);
136 if (*new_item->name == '-')
137 width--;
138 if (width > menu->width)
139 menu->width = width;
140 }
141
142 struct menu *
143 menu_create(const char *title)
144 {
145 struct menu *menu;
146
147 menu = xcalloc(1, sizeof *menu);
148 menu->title = xstrdup(title);
149 menu->width = format_width(title);
150
151 return (menu);
152 }
153
154 void
155 menu_free(struct menu *menu)
156 {
157 u_int i;
158
159 for (i = 0; i < menu->count; i++) {
160 free((void *)menu->items[i].name);
161 free((void *)menu->items[i].command);
162 }
163 free(menu->items);
164
165 free((void *)menu->title);
166 free(menu);
167 }
168
169 struct screen *
170 menu_mode_cb(__unused struct client *c, void *data, u_int *cx, u_int *cy)
171 {
172 struct menu_data *md = data;
173
174 *cx = md->px + 2;
175 if (md->choice == -1)
176 *cy = md->py;
177 else
178 *cy = md->py + 1 + md->choice;
179
180 return (&md->s);
181 }
182
183 /* Return parts of the input range which are not obstructed by the menu. */
184 void
185 menu_check_cb(__unused struct client *c, void *data, u_int px, u_int py,
186 u_int nx, struct overlay_ranges *r)
187 {
188 struct menu_data *md = data;
189 struct menu *menu = md->menu;
190
191 server_client_overlay_range(md->px, md->py, menu->width + 4,
192 menu->count + 2, px, py, nx, r);
193 }
194
195 void
196 menu_draw_cb(struct client *c, void *data,
197 __unused struct screen_redraw_ctx *rctx)
198 {
199 struct menu_data *md = data;
200 struct tty *tty = &c->tty;
201 struct screen *s = &md->s;
202 struct menu *menu = md->menu;
203 struct screen_write_ctx ctx;
204 u_int i, px = md->px, py = md->py;
205
206 screen_write_start(&ctx, s);
207 screen_write_clearscreen(&ctx, 8);
208
209 if (md->border_lines != BOX_LINES_NONE) {
210 screen_write_box(&ctx, menu->width + 4, menu->count + 2,
211 md->border_lines, &md->border_style, menu->title);
212 }
213
214 screen_write_menu(&ctx, menu, md->choice, md->border_lines,
215 &md->style, &md->border_style, &md->selected_style);
216 screen_write_stop(&ctx);
217
218 for (i = 0; i < screen_size_y(&md->s); i++) {
219 tty_draw_line(tty, s, 0, i, menu->width + 4, px, py + i,
220 &grid_default_cell, NULL);
221 }
222 }
223
224 void
225 menu_free_cb(__unused struct client *c, void *data)
226 {
227 struct menu_data *md = data;
228
229 if (md->item != NULL)
230 cmdq_continue(md->item);
231
232 if (md->cb != NULL)
233 md->cb(md->menu, UINT_MAX, KEYC_NONE, md->data);
234
235 screen_free(&md->s);
236 menu_free(md->menu);
237 free(md);
238 }
239
240 int
241 menu_key_cb(struct client *c, void *data, struct key_event *event)
242 {
243 struct menu_data *md = data;
244 struct menu *menu = md->menu;
245 struct mouse_event *m = &event->m;
246 u_int i;
247 int count = menu->count, old = md->choice;
248 const char *name = NULL;
249 const struct menu_item *item;
250 struct cmdq_state *state;
251 enum cmd_parse_status status;
252 char *error;
253
254 if (KEYC_IS_MOUSE(event->key)) {
255 if (md->flags & MENU_NOMOUSE) {
256 if (MOUSE_BUTTONS(m->b) != MOUSE_BUTTON_1)
257 return (1);
258 return (0);
259 }
260 if (m->x < md->px ||
261 m->x > md->px + 4 + menu->width ||
262 m->y < md->py + 1 ||
263 m->y > md->py + 1 + count - 1) {
264 if (~md->flags & MENU_STAYOPEN) {
265 if (MOUSE_RELEASE(m->b))
266 return (1);
267 } else {
268 if (!MOUSE_RELEASE(m->b) &&
269 !MOUSE_WHEEL(m->b) &&
270 !MOUSE_DRAG(m->b))
271 return (1);
272 }
273 if (md->choice != -1) {
274 md->choice = -1;
275 c->flags |= CLIENT_REDRAWOVERLAY;
276 }
277 return (0);
278 }
279 if (~md->flags & MENU_STAYOPEN) {
280 if (MOUSE_RELEASE(m->b))
281 goto chosen;
282 } else {
283 if (!MOUSE_WHEEL(m->b) && !MOUSE_DRAG(m->b))
284 goto chosen;
285 }
286 md->choice = m->y - (md->py + 1);
287 if (md->choice != old)
288 c->flags |= CLIENT_REDRAWOVERLAY;
289 return (0);
290 }
291 for (i = 0; i < (u_int)count; i++) {
292 name = menu->items[i].name;
293 if (name == NULL || *name == '-')
294 continue;
295 if (event->key == menu->items[i].key) {
296 md->choice = i;
297 goto chosen;
298 }
299 }
300 switch (event->key & ~KEYC_MASK_FLAGS) {
301 case KEYC_UP:
302 case 'k':
303 if (old == -1)
304 old = 0;
305 do {
306 if (md->choice == -1 || md->choice == 0)
307 md->choice = count - 1;
308 else
309 md->choice--;
310 name = menu->items[md->choice].name;
311 } while ((name == NULL || *name == '-') && md->choice != old);
312 c->flags |= CLIENT_REDRAWOVERLAY;
313 return (0);
314 case KEYC_BSPACE:
315 if (~md->flags & MENU_TAB)
316 break;
317 return (1);
318 case '\011': /* Tab */
319 if (~md->flags & MENU_TAB)
320 break;
321 if (md->choice == count - 1)
322 return (1);
323 /* FALLTHROUGH */
324 case KEYC_DOWN:
325 case 'j':
326 if (old == -1)
327 old = 0;
328 do {
329 if (md->choice == -1 || md->choice == count - 1)
330 md->choice = 0;
331 else
332 md->choice++;
333 name = menu->items[md->choice].name;
334 } while ((name == NULL || *name == '-') && md->choice != old);
335 c->flags |= CLIENT_REDRAWOVERLAY;
336 return (0);
337 case KEYC_PPAGE:
338 case '\002': /* C-b */
339 if (md->choice < 6)
340 md->choice = 0;
341 else {
342 i = 5;
343 while (i > 0) {
344 md->choice--;
345 name = menu->items[md->choice].name;
346 if (md->choice != 0 &&
347 (name != NULL && *name != '-'))
348 i--;
349 else if (md->choice == 0)
350 break;
351 }
352 }
353 c->flags |= CLIENT_REDRAWOVERLAY;
354 break;
355 case KEYC_NPAGE:
356 if (md->choice > count - 6) {
357 md->choice = count - 1;
358 name = menu->items[md->choice].name;
359 } else {
360 i = 5;
361 while (i > 0) {
362 md->choice++;
363 name = menu->items[md->choice].name;
364 if (md->choice != count - 1 &&
365 (name != NULL && *name != '-'))
366 i++;
367 else if (md->choice == count - 1)
368 break;
369 }
370 }
371 while (name == NULL || *name == '-') {
372 md->choice--;
373 name = menu->items[md->choice].name;
374 }
375 c->flags |= CLIENT_REDRAWOVERLAY;
376 break;
377 case 'g':
378 case KEYC_HOME:
379 md->choice = 0;
380 name = menu->items[md->choice].name;
381 while (name == NULL || *name == '-') {
382 md->choice++;
383 name = menu->items[md->choice].name;
384 }
385 c->flags |= CLIENT_REDRAWOVERLAY;
386 break;
387 case 'G':
388 case KEYC_END:
389 md->choice = count - 1;
390 name = menu->items[md->choice].name;
391 while (name == NULL || *name == '-') {
392 md->choice--;
393 name = menu->items[md->choice].name;
394 }
395 c->flags |= CLIENT_REDRAWOVERLAY;
396 break;
397 case '\006': /* C-f */
398 break;
399 case '\r':
400 goto chosen;
401 case '\033': /* Escape */
402 case '\003': /* C-c */
403 case '\007': /* C-g */
404 case 'q':
405 return (1);
406 }
407 return (0);
408
409 chosen:
410 if (md->choice == -1)
411 return (1);
412 item = &menu->items[md->choice];
413 if (item->name == NULL || *item->name == '-') {
414 if (md->flags & MENU_STAYOPEN)
415 return (0);
416 return (1);
417 }
418 if (md->cb != NULL) {
419 md->cb(md->menu, md->choice, item->key, md->data);
420 md->cb = NULL;
421 return (1);
422 }
423
424 if (md->item != NULL)
425 event = cmdq_get_event(md->item);
426 else
427 event = NULL;
428 state = cmdq_new_state(&md->fs, event, 0);
429
430 status = cmd_parse_and_append(item->command, NULL, c, state, &error);
431 if (status == CMD_PARSE_ERROR) {
432 cmdq_append(c, cmdq_get_error(error));
433 free(error);
434 }
435 cmdq_free_state(state);
436
437 return (1);
438 }
439
440 static void
441 menu_set_style(struct client *c, struct grid_cell *gc, const char *style,
442 const char *option)
443 {
444 struct style sytmp;
445 struct options *o = c->session->curw->window->options;
446
447 memcpy(gc, &grid_default_cell, sizeof *gc);
448 style_apply(gc, o, option, NULL);
449 if (style != NULL) {
450 style_set(&sytmp, &grid_default_cell);
451 if (style_parse(&sytmp, gc, style) == 0) {
452 gc->fg = sytmp.gc.fg;
453 gc->bg = sytmp.gc.bg;
454 }
455 }
456 gc->attr = 0;
457 }
458
459 struct menu_data *
460 menu_prepare(struct menu *menu, int flags, int starting_choice,
461 struct cmdq_item *item, u_int px, u_int py, struct client *c,
462 enum box_lines lines, const char *style, const char *selected_style,
463 const char *border_style, struct cmd_find_state *fs, menu_choice_cb cb,
464 void *data)
465 {
466 struct menu_data *md;
467 int choice;
468 const char *name;
469 struct options *o = c->session->curw->window->options;
470
471 if (c->tty.sx < menu->width + 4 || c->tty.sy < menu->count + 2)
472 return (NULL);
473 if (px + menu->width + 4 > c->tty.sx)
474 px = c->tty.sx - menu->width - 4;
475 if (py + menu->count + 2 > c->tty.sy)
476 py = c->tty.sy - menu->count - 2;
477
478 if (lines == BOX_LINES_DEFAULT)
479 lines = options_get_number(o, "menu-border-lines");
480
481 md = xcalloc(1, sizeof *md);
482 md->item = item;
483 md->flags = flags;
484 md->border_lines = lines;
485
486 menu_set_style(c, &md->style, style, "menu-style");
487 menu_set_style(c, &md->selected_style, selected_style,
488 "menu-selected-style");
489 menu_set_style(c, &md->border_style, border_style, "menu-border-style");
490
491 if (fs != NULL)
492 cmd_find_copy_state(&md->fs, fs);
493 screen_init(&md->s, menu->width + 4, menu->count + 2, 0);
494 if (~md->flags & MENU_NOMOUSE)
495 md->s.mode |= (MODE_MOUSE_ALL|MODE_MOUSE_BUTTON);
496 md->s.mode &= ~MODE_CURSOR;
497
498 md->px = px;
499 md->py = py;
500
501 md->menu = menu;
502 md->choice = -1;
503
504 if (md->flags & MENU_NOMOUSE) {
505 if (starting_choice >= (int)menu->count) {
506 starting_choice = menu->count - 1;
507 choice = starting_choice + 1;
508 for (;;) {
509 name = menu->items[choice - 1].name;
510 if (name != NULL && *name != '-') {
511 md->choice = choice - 1;
512 break;
513 }
514 if (--choice == 0)
515 choice = menu->count;
516 if (choice == starting_choice + 1)
517 break;
518 }
519 } else if (starting_choice >= 0) {
520 choice = starting_choice;
521 for (;;) {
522 name = menu->items[choice].name;
523 if (name != NULL && *name != '-') {
524 md->choice = choice;
525 break;
526 }
527 if (++choice == (int)menu->count)
528 choice = 0;
529 if (choice == starting_choice)
530 break;
531 }
532 }
533 }
534
535 md->cb = cb;
536 md->data = data;
537 return (md);
538 }
539
540 int
541 menu_display(struct menu *menu, int flags, int starting_choice,
542 struct cmdq_item *item, u_int px, u_int py, struct client *c,
543 enum box_lines lines, const char *style, const char *selected_style,
544 const char *border_style, struct cmd_find_state *fs, menu_choice_cb cb,
545 void *data)
546 {
547 struct menu_data *md;
548
549 md = menu_prepare(menu, flags, starting_choice, item, px, py, c, lines,
550 style, selected_style, border_style, fs, cb, data);
551 if (md == NULL)
552 return (-1);
553 server_client_set_overlay(c, 0, NULL, menu_mode_cb, menu_draw_cb,
554 menu_key_cb, menu_free_cb, NULL, md);
555 return (0);
556 }
tmux -- terminal multiplexer similar to GNU Screen