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