menu.c

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