src/menu.c

   1 /* Pulldown menu code.
   2    Copyright (C) 1994 Miguel de Icaza.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 #include <config.h>
  19
  20 #include <ctype.h>
  21 #include <stdarg.h>
  22 #include <string.h>
  23
  24 #include <sys/types.h>
  25
  26 #include "global.h"
  27 #include "tty.h"
  28 #include "menu.h"
  29 #include "help.h"
  30 #include "dialog.h"
  31 #include "color.h"
  32 #include "main.h"
  33 #include "mouse.h"
  34 #include "win.h"
  35 #include "key.h"        /* For mi_getch() */
  36
  37 int menubar_visible = 1;        /* This is the new default */
  38
  39 static void
  40 menu_scan_hotkey (Menu *menu)
  41 {
  42     char *cp = strchr (menu->name, '&');
  43
  44     if (cp != NULL && cp[1] != '\0') {
  45         g_strlcpy (cp, cp + 1, strlen (cp));
  46         menu->hotkey = tolower ((unsigned char) *cp);
  47     } else
  48         menu->hotkey = 0;
  49 }
  50
  51 Menu *
  52 create_menu (const char *name, menu_entry *entries, int count, const char *help_node)
  53 {
  54     Menu *menu;
  55     const char *cp;
  56
  57     menu = (Menu *) g_malloc (sizeof (*menu));
  58     menu->count = count;
  59     menu->max_entry_len = 20;
  60     menu->entries = entries;
  61
  62     if (entries != (menu_entry*) NULL) {
  63         register menu_entry* mp;
  64         for (mp = entries; count--; mp++) {
  65             if (mp->text[0] != '\0') {
  66 #ifdef ENABLE_NLS
  67                 mp->text = _(mp->text);
  68 #endif /* ENABLE_NLS */
  69                 cp = strchr (mp->text,'&');
  70
  71                 if (cp != NULL && *(cp+1) != '\0') {
  72                     mp->hot_key = tolower ((unsigned char) *(cp+1));
  73                     menu->max_entry_len = max ((int) (strlen (mp->text) - 1),
  74                         menu->max_entry_len);
  75                 } else {
  76                     menu->max_entry_len = max ((int) strlen (mp->text),
  77                         menu->max_entry_len);
  78                 }
  79             }
  80         }
  81     }
  82
  83     menu->name = g_strdup (name);
  84     menu_scan_hotkey(menu);
  85     menu->start_x = 0;
  86     menu->help_node = g_strdup (help_node);
  87     return menu;
  88 }
  89
  90 static void menubar_drop_compute (WMenu *menubar)
  91 {
  92     menubar->max_entry_len = menubar->menu [menubar->selected]->max_entry_len;
  93 }
  94
  95 static void menubar_paint_idx (WMenu *menubar, int idx, int color)
  96 {
  97     const Menu *menu = menubar->menu [menubar->selected];
  98     const int y = 2 + idx;
  99         int x = menubar-> menu[menubar->selected]->start_x;
 100
 101         if (x + menubar->max_entry_len + 3 > menubar->widget.cols)
 102                 x = menubar->widget.cols - menubar->max_entry_len - 3;
 103
 104     widget_move (&menubar->widget, y, x);
 105     attrset (color);
 106     hline (' ', menubar->max_entry_len+2);
 107     if (!*menu->entries [idx].text) {
 108         attrset (SELECTED_COLOR);
 109         widget_move (&menubar->widget, y, x + 1);
 110         hline (slow_terminal ? ' ' : ACS_HLINE, menubar->max_entry_len);
 111     } else {
 112         const char *text;
 113
 114         addch((unsigned char)menu->entries [idx].first_letter);
 115         for (text = menu->entries [idx].text; *text; text++)
 116         {
 117                 if (*text != '&')
 118                     addch(*text);
 119                 else {
 120                     attrset (color == MENU_SELECTED_COLOR ?
 121                         MENU_HOTSEL_COLOR : MENU_HOT_COLOR);
 122                     addch(*(++text));
 123                     attrset(color);
 124                 }
 125         }
 126     }
 127     widget_move (&menubar->widget, y, x + 1);
 128 }
 129
 130 static inline void menubar_draw_drop (WMenu *menubar)
 131 {
 132     const int count = (menubar->menu [menubar->selected])->count;
 133     int   i;
 134     int   sel = menubar->subsel;
 135     int   column = menubar-> menu[menubar->selected]->start_x - 1;
 136
 137         if (column + menubar->max_entry_len + 4 > menubar->widget.cols)
 138                 column = menubar->widget.cols - menubar->max_entry_len - 4;
 139
 140     attrset (SELECTED_COLOR);
 141     draw_box (menubar->widget.parent,
 142               menubar->widget.y+1, menubar->widget.x + column,
 143               count+2, menubar->max_entry_len + 4);
 144
 145     column++;
 146     for (i = 0; i < count; i++){
 147         if (i == sel)
 148             continue;
 149         menubar_paint_idx (menubar, i, MENU_ENTRY_COLOR);
 150     }
 151     menubar_paint_idx (menubar, sel, MENU_SELECTED_COLOR);
 152 }
 153
 154 static void menubar_draw (WMenu *menubar)
 155 {
 156     const int items = menubar->items;
 157     int   i;
 158
 159     /* First draw the complete menubar */
 160     attrset (SELECTED_COLOR);
 161     widget_move (&menubar->widget, 0, 0);
 162
 163     /* ncurses bug: it should work with hline but it does not */
 164     for (i =  menubar->widget.cols; i; i--)
 165         addch (' ');
 166
 167     attrset (SELECTED_COLOR);
 168     /* Now each one of the entries */
 169     for (i = 0; i < items; i++){
 170         if (menubar->active)
 171             attrset(i == menubar->selected?MENU_SELECTED_COLOR:SELECTED_COLOR);
 172         widget_move (&menubar->widget, 0, menubar->menu [i]->start_x);
 173         printw ("%s", menubar->menu [i]->name);
 174     }
 175
 176     if (menubar->dropped)
 177         menubar_draw_drop (menubar);
 178     else
 179         widget_move (&menubar->widget, 0,
 180                 menubar-> menu[menubar->selected]->start_x);
 181 }
 182
 183 static inline void menubar_remove (WMenu *menubar)
 184 {
 185     menubar->subsel = 0;
 186     if (menubar->dropped){
 187         menubar->dropped = 0;
 188         do_refresh ();
 189         menubar->dropped = 1;
 190     }
 191 }
 192
 193 static void menubar_left (WMenu *menu)
 194 {
 195     menubar_remove (menu);
 196     menu->selected = (menu->selected - 1) % menu->items;
 197     if (menu->selected < 0)
 198         menu->selected = menu->items -1;
 199     menubar_drop_compute (menu);
 200     menubar_draw (menu);
 201 }
 202
 203 static void menubar_right (WMenu *menu)
 204 {
 205     menubar_remove (menu);
 206     menu->selected = (menu->selected + 1) % menu->items;
 207     menubar_drop_compute (menu);
 208     menubar_draw (menu);
 209 }
 210
 211 static void
 212 menubar_finish (WMenu *menubar)
 213 {
 214     menubar->dropped = 0;
 215     menubar->active = 0;
 216     menubar->widget.lines = 1;
 217     widget_want_hotkey (menubar->widget, 0);
 218
 219     dlg_select_by_id (menubar->widget.parent, menubar->previous_widget);
 220     do_refresh ();
 221 }
 222
 223 static void menubar_drop (WMenu *menubar, int selected)
 224 {
 225     menubar->dropped = 1;
 226     menubar->selected = selected;
 227     menubar->subsel = 0;
 228     menubar_drop_compute (menubar);
 229     menubar_draw (menubar);
 230 }
 231
 232 static void menubar_execute (WMenu *menubar, int entry)
 233 {
 234     const Menu *menu = menubar->menu [menubar->selected];
 235     const callfn call_back = menu->entries [entry].call_back;
 236
 237     is_right = menubar->selected != 0;
 238
 239     /* This used to be the other way round, i.e. first callback and
 240        then menubar_finish. The new order (hack?) is needed to make
 241        change_panel () work which is used in quick_view_cmd () -- Norbert
 242     */
 243     menubar_finish (menubar);
 244     (*call_back) ();
 245     do_refresh ();
 246 }
 247
 248 static void menubar_move (WMenu *menubar, int step)
 249 {
 250     const Menu *menu = menubar->menu [menubar->selected];
 251
 252     menubar_paint_idx (menubar, menubar->subsel, MENU_ENTRY_COLOR);
 253     do {
 254         menubar->subsel += step;
 255         if (menubar->subsel < 0)
 256             menubar->subsel = menu->count - 1;
 257
 258         menubar->subsel %= menu->count;
 259     } while  (!menu->entries [menubar->subsel].call_back);
 260     menubar_paint_idx (menubar, menubar->subsel, MENU_SELECTED_COLOR);
 261 }
 262
 263 static int menubar_handle_key (WMenu *menubar, int key)
 264 {
 265     int   i;
 266
 267     /* Lowercase */
 268     if (key < 256 && isalpha (key)) /* Linux libc.so.5.x.x bug fix */
 269         key = tolower (key);
 270
 271     if (is_abort_char (key)){
 272         menubar_finish (menubar);
 273         return 1;
 274     }
 275
 276     if (key == KEY_F(1)) {
 277         if (menubar->dropped) {
 278             interactive_display (NULL,
 279                     (menubar->menu [menubar->selected])->help_node);
 280         } else {
 281             interactive_display (NULL, "[Menu Bar]");
 282         }
 283         menubar_draw (menubar);
 284         return 1;
 285     }
 286
 287     if (key == KEY_LEFT || key == XCTRL('b')){
 288         menubar_left (menubar);
 289         return 1;
 290     } else if (key == KEY_RIGHT || key == XCTRL ('f')){
 291         menubar_right (menubar);
 292         return 1;
 293     }
 294
 295     if (!menubar->dropped){
 296         const int items = menubar->items;
 297         for (i = 0; i < items; i++){
 298             const Menu *menu = menubar->menu [i];
 299
 300             if (menu->hotkey == key){
 301                 menubar_drop (menubar, i);
 302                 return 1;
 303             }
 304         }
 305         if (key == KEY_ENTER || key == XCTRL ('n') || key == KEY_DOWN
 306             || key == '\n'){
 307             menubar_drop (menubar, menubar->selected);
 308             return 1;
 309         }
 310         return 1;
 311     } else {
 312         const int selected = menubar->selected;
 313         const Menu *menu = menubar->menu [selected];
 314         const int items = menu->count;
 315
 316         for (i = 0; i < items; i++){
 317             if (!menu->entries [i].call_back)
 318                 continue;
 319
 320                 if (key != menu->entries [i].hot_key)
 321                         continue;
 322
 323             menubar_execute (menubar, i);
 324             return 1;
 325         }
 326
 327         if (key == KEY_ENTER || key == '\n'){
 328             menubar_execute (menubar, menubar->subsel);
 329             return 1;
 330         }
 331
 332
 333         if (key == KEY_DOWN || key == XCTRL ('n'))
 334             menubar_move (menubar, 1);
 335
 336         if (key == KEY_UP || key == XCTRL ('p'))
 337             menubar_move (menubar, -1);
 338     }
 339     return 0;
 340 }
 341
 342 static cb_ret_t
 343 menubar_callback (Widget *w, widget_msg_t msg, int parm)
 344 {
 345     WMenu *menubar = (WMenu *) w;
 346
 347     switch (msg) {
 348         /* We do not want the focus unless we have been activated */
 349     case WIDGET_FOCUS:
 350         if (!menubar->active)
 351             return MSG_NOT_HANDLED;
 352
 353         widget_want_cursor (menubar->widget, 1);
 354
 355         /* Trick to get all the mouse events */
 356         menubar->widget.lines = LINES;
 357
 358         /* Trick to get all of the hotkeys */
 359         widget_want_hotkey (menubar->widget, 1);
 360         menubar->subsel = 0;
 361         menubar_drop_compute (menubar);
 362         menubar_draw (menubar);
 363         return MSG_HANDLED;
 364
 365         /* We don't want the buttonbar to activate while using the menubar */
 366     case WIDGET_HOTKEY:
 367     case WIDGET_KEY:
 368         if (menubar->active) {
 369             menubar_handle_key (menubar, parm);
 370             return MSG_HANDLED;
 371         } else
 372             return MSG_NOT_HANDLED;
 373
 374     case WIDGET_CURSOR:
 375         /* Put the cursor in a suitable place */
 376         return MSG_NOT_HANDLED;
 377
 378     case WIDGET_UNFOCUS:
 379         if (menubar->active)
 380             return MSG_NOT_HANDLED;
 381         else {
 382             widget_want_cursor (menubar->widget, 0);
 383             return MSG_HANDLED;
 384         }
 385
 386     case WIDGET_DRAW:
 387         if (menubar_visible)
 388             menubar_draw (menubar);
 389         return MSG_HANDLED;
 390
 391     default:
 392         return default_proc (msg, parm);
 393     }
 394 }
 395
 396 static int
 397 menubar_event    (Gpm_Event *event, void *data)
 398 {
 399     WMenu *menubar = data;
 400     int was_active;
 401     int new_selection;
 402     int left_x, right_x, bottom_y;
 403
 404     if (!(event->type & (GPM_UP|GPM_DOWN|GPM_DRAG)))
 405         return MOU_NORMAL;
 406
 407     if (!menubar->dropped){
 408         menubar->previous_widget = menubar->widget.parent->current->dlg_id;
 409         menubar->active = 1;
 410         menubar->dropped = 1;
 411         was_active = 0;
 412     } else
 413         was_active = 1;
 414
 415     /* Mouse operations on the menubar */
 416     if (event->y == 1 || !was_active){
 417         if (event->type & GPM_UP)
 418             return MOU_NORMAL;
 419
 420         new_selection = 0;
 421         while (new_selection < menubar->items
 422                 && event->x > menubar->menu[new_selection]->start_x
 423         )
 424                 new_selection++;
 425
 426         if (new_selection) /* Don't set the invalid value -1 */
 427                 --new_selection;
 428
 429         if (!was_active){
 430             menubar->selected = new_selection;
 431             dlg_select_widget (menubar);
 432             menubar_drop_compute (menubar);
 433             menubar_draw (menubar);
 434             return MOU_NORMAL;
 435         }
 436
 437         menubar_remove (menubar);
 438
 439         menubar->selected = new_selection;
 440
 441         menubar_drop_compute (menubar);
 442         menubar_draw (menubar);
 443         return MOU_NORMAL;
 444     }
 445
 446     if (!menubar->dropped)
 447         return MOU_NORMAL;
 448
 449     /* Ignore the events on anything below the third line */
 450     if (event->y <= 2)
 451         return MOU_NORMAL;
 452
 453     /* Else, the mouse operation is on the menus or it is not */
 454         left_x = menubar->menu[menubar->selected]->start_x;
 455         right_x = left_x + menubar->max_entry_len + 4;
 456         if (right_x > menubar->widget.cols)
 457         {
 458                 left_x = menubar->widget.cols - menubar->max_entry_len - 3;
 459                 right_x = menubar->widget.cols - 1;
 460         }
 461
 462     bottom_y = (menubar->menu [menubar->selected])->count + 3;
 463
 464     if ((event->x > left_x) && (event->x < right_x) && (event->y < bottom_y)){
 465         int pos = event->y - 3;
 466
 467         if (!menubar->menu [menubar->selected]->entries [pos].call_back)
 468             return MOU_NORMAL;
 469
 470         menubar_paint_idx (menubar, menubar->subsel, MENU_ENTRY_COLOR);
 471         menubar->subsel = pos;
 472         menubar_paint_idx (menubar, menubar->subsel, MENU_SELECTED_COLOR);
 473
 474         if (event->type & GPM_UP)
 475             menubar_execute (menubar, pos);
 476     } else
 477         if (event->type & GPM_DOWN)
 478             menubar_finish (menubar);
 479
 480     return MOU_NORMAL;
 481 }
 482
 483 /*
 484  * Properly space menubar items. Should be called when menubar is created
 485  * and also when widget width is changed (i.e. upon xterm resize).
 486  */
 487 void
 488 menubar_arrange(WMenu* menubar)
 489 {
 490         register int i, start_x = 1;
 491         int items = menubar->items;
 492
 493 #ifndef RESIZABLE_MENUBAR
 494         int gap = 3;
 495
 496         for (i = 0; i < items; i++)
 497         {
 498                 int len = strlen(menubar->menu[i]->name);
 499                 menubar->menu[i]->start_x = start_x;
 500                 start_x += len + gap;
 501         }
 502
 503 #else /* RESIZABLE_MENUBAR */
 504
 505         int gap = menubar->widget.cols - 2;
 506
 507         /* First, calculate gap between items... */
 508         for (i = 0; i < items; i++)
 509         {
 510                 /* preserve length here, to be used below */
 511                 gap -= (menubar->menu[i]->start_x = strlen(menubar->menu[i]->name));
 512         }
 513
 514         gap /= (items - 1);
 515
 516         if (gap <= 0)
 517         {
 518                 /* We are out of luck - window is too narrow... */
 519                 gap = 1;
 520         }
 521
 522         /* ...and now fix start positions of menubar items */
 523         for (i = 0; i < items; i++)
 524         {
 525                 int len = menubar->menu[i]->start_x;
 526                 menubar->menu[i]->start_x = start_x;
 527                 start_x += len + gap;
 528         }
 529 #endif /* RESIZABLE_MENUBAR */
 530 }
 531
 532 void
 533 destroy_menu (Menu *menu)
 534 {
 535     g_free (menu->name);
 536     g_free (menu->help_node);
 537     g_free (menu);
 538 }
 539
 540 WMenu *
 541 menubar_new (int y, int x, int cols, Menu *menu[], int items)
 542 {
 543     WMenu *menubar = g_new0 (WMenu, 1); /* FIXME: subsel used w/o being set */
 544
 545     init_widget (&menubar->widget, y, x, 1, cols,
 546                  menubar_callback, menubar_event);
 547     menubar->menu = menu;
 548     menubar->active = 0;
 549     menubar->dropped = 0;
 550     menubar->items = items;
 551     menubar->selected = 0;
 552     widget_want_cursor (menubar->widget, 0);
 553     menubar_arrange (menubar);
 554
 555     return menubar;
 556 }