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         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 }