lib/widget/menu.c

   1 /*
   2    Pulldown menu code
   3
   4    Copyright (C) 1994-2016
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Andrew Borodin <aborodin@vmail.ru>, 2012, 2013
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /** \file menu.c
  27  *  \brief Source: pulldown menu code
  28  */
  29
  30 #include <config.h>
  31
  32 #include <ctype.h>
  33 #include <stdarg.h>
  34 #include <string.h>
  35 #include <sys/types.h>
  36
  37 #include "lib/global.h"
  38
  39 #include "lib/tty/tty.h"
  40 #include "lib/skin.h"
  41 #include "lib/tty/mouse.h"
  42 #include "lib/tty/key.h"        /* key macros */
  43 #include "lib/strutil.h"
  44 #include "lib/widget.h"
  45 #include "lib/event.h"          /* mc_event_raise() */
  46
  47 /*** global variables ****************************************************************************/
  48
  49 /*** file scope macro definitions ****************************************************************/
  50
  51 #define MENUENTRY(x) ((menu_entry_t *)(x))
  52 #define MENU(x) ((menu_t *)(x))
  53
  54 /*** file scope type declarations ****************************************************************/
  55
  56 struct menu_entry_t
  57 {
  58     unsigned char first_letter;
  59     hotkey_t text;
  60     long command;
  61     char *shortcut;
  62 };
  63
  64 struct menu_t
  65 {
  66     int start_x;                /* position relative to menubar start */
  67     hotkey_t text;
  68     GList *entries;
  69     size_t max_entry_len;       /* cached max length of entry texts (text + shortcut) */
  70     size_t max_hotkey_len;      /* cached max length of shortcuts */
  71     unsigned int selected;      /* pointer to current menu entry */
  72     char *help_node;
  73 };
  74
  75 /*** file scope variables ************************************************************************/
  76
  77 /*** file scope functions ************************************************************************/
  78 /* --------------------------------------------------------------------------------------------- */
  79
  80 static void
  81 menu_arrange (menu_t * menu, dlg_shortcut_str get_shortcut)
  82 {
  83     if (menu != NULL)
  84     {
  85         GList *i;
  86         size_t max_shortcut_len = 0;
  87
  88         menu->max_entry_len = 1;
  89         menu->max_hotkey_len = 1;
  90
  91         for (i = menu->entries; i != NULL; i = g_list_next (i))
  92         {
  93             menu_entry_t *entry = MENUENTRY (i->data);
  94
  95             if (entry != NULL)
  96             {
  97                 size_t len;
  98
  99                 len = (size_t) hotkey_width (entry->text);
 100                 menu->max_hotkey_len = max (menu->max_hotkey_len, len);
 101
 102                 if (get_shortcut != NULL)
 103                     entry->shortcut = get_shortcut (entry->command);
 104
 105                 if (entry->shortcut != NULL)
 106                 {
 107                     len = (size_t) str_term_width1 (entry->shortcut);
 108                     max_shortcut_len = max (max_shortcut_len, len);
 109                 }
 110             }
 111         }
 112
 113         menu->max_entry_len = menu->max_hotkey_len + max_shortcut_len;
 114     }
 115 }
 116
 117 /* --------------------------------------------------------------------------------------------- */
 118
 119 static void
 120 menubar_paint_idx (WMenuBar * menubar, unsigned int idx, int color)
 121 {
 122     Widget *w = WIDGET (menubar);
 123     const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 124     const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, idx));
 125     const int y = 2 + idx;
 126     int x = menu->start_x;
 127
 128     if (x + menu->max_entry_len + 4 > (gsize) w->cols)
 129         x = w->cols - menu->max_entry_len - 4;
 130
 131     if (entry == NULL)
 132     {
 133         /* menu separator */
 134         tty_setcolor (MENU_ENTRY_COLOR);
 135
 136         widget_move (w, y, x - 1);
 137         tty_print_alt_char (ACS_LTEE, FALSE);
 138         tty_draw_hline (w->y + y, w->x + x, ACS_HLINE, menu->max_entry_len + 3);
 139         widget_move (w, y, x + menu->max_entry_len + 3);
 140         tty_print_alt_char (ACS_RTEE, FALSE);
 141     }
 142     else
 143     {
 144         int yt, xt;
 145
 146         /* menu text */
 147         tty_setcolor (color);
 148         widget_move (w, y, x);
 149         tty_print_char ((unsigned char) entry->first_letter);
 150         tty_getyx (&yt, &xt);
 151         tty_draw_hline (yt, xt, ' ', menu->max_entry_len + 2);  /* clear line */
 152         tty_print_string (entry->text.start);
 153
 154         if (entry->text.hotkey != NULL)
 155         {
 156             tty_setcolor (color == MENU_SELECTED_COLOR ? MENU_HOTSEL_COLOR : MENU_HOT_COLOR);
 157             tty_print_string (entry->text.hotkey);
 158             tty_setcolor (color);
 159         }
 160
 161         if (entry->text.end != NULL)
 162             tty_print_string (entry->text.end);
 163
 164         if (entry->shortcut != NULL)
 165         {
 166             widget_move (w, y, x + menu->max_hotkey_len + 3);
 167             tty_print_string (entry->shortcut);
 168         }
 169
 170         /* move cursor to the start of entry text */
 171         widget_move (w, y, x + 1);
 172     }
 173 }
 174
 175 /* --------------------------------------------------------------------------------------------- */
 176
 177 static void
 178 menubar_draw_drop (WMenuBar * menubar)
 179 {
 180     Widget *w = WIDGET (menubar);
 181     const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 182     const unsigned int count = g_list_length (menu->entries);
 183     int column = menu->start_x - 1;
 184     unsigned int i;
 185
 186     if (column + menu->max_entry_len + 5 > (gsize) w->cols)
 187         column = w->cols - menu->max_entry_len - 5;
 188
 189     tty_setcolor (MENU_ENTRY_COLOR);
 190     tty_draw_box (w->y + 1, w->x + column, count + 2, menu->max_entry_len + 5, FALSE);
 191
 192     for (i = 0; i < count; i++)
 193         menubar_paint_idx (menubar, i,
 194                            i == menu->selected ? MENU_SELECTED_COLOR : MENU_ENTRY_COLOR);
 195 }
 196
 197 /* --------------------------------------------------------------------------------------------- */
 198
 199 static void
 200 menubar_set_color (WMenuBar * menubar, gboolean current, gboolean hotkey)
 201 {
 202     if (!menubar->is_active)
 203         tty_setcolor (MENU_INACTIVE_COLOR);
 204     else if (current)
 205         tty_setcolor (hotkey ? MENU_HOTSEL_COLOR : MENU_SELECTED_COLOR);
 206     else
 207         tty_setcolor (hotkey ? MENU_HOT_COLOR : MENU_ENTRY_COLOR);
 208 }
 209
 210 /* --------------------------------------------------------------------------------------------- */
 211
 212 static void
 213 menubar_draw (WMenuBar * menubar)
 214 {
 215     Widget *w = WIDGET (menubar);
 216     GList *i;
 217
 218     /* First draw the complete menubar */
 219     tty_setcolor (menubar->is_active ? MENU_ENTRY_COLOR : MENU_INACTIVE_COLOR);
 220     tty_draw_hline (w->y, w->x, ' ', w->cols);
 221
 222     /* Now each one of the entries */
 223     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 224     {
 225         menu_t *menu = MENU (i->data);
 226         gboolean is_selected = (menubar->selected == (gsize) g_list_position (menubar->menu, i));
 227
 228         menubar_set_color (menubar, is_selected, FALSE);
 229         widget_move (w, 0, menu->start_x);
 230
 231         tty_print_char (' ');
 232         tty_print_string (menu->text.start);
 233
 234         if (menu->text.hotkey != NULL)
 235         {
 236             menubar_set_color (menubar, is_selected, TRUE);
 237             tty_print_string (menu->text.hotkey);
 238             menubar_set_color (menubar, is_selected, FALSE);
 239         }
 240
 241         if (menu->text.end != NULL)
 242             tty_print_string (menu->text.end);
 243
 244         tty_print_char (' ');
 245     }
 246
 247     if (menubar->is_dropped)
 248         menubar_draw_drop (menubar);
 249     else
 250         widget_move (w, 0, MENU (g_list_nth_data (menubar->menu, menubar->selected))->start_x);
 251 }
 252
 253 /* --------------------------------------------------------------------------------------------- */
 254
 255 static void
 256 menubar_remove (WMenuBar * menubar)
 257 {
 258     WDialog *h;
 259
 260     if (!menubar->is_dropped)
 261         return;
 262
 263     /* HACK: before refresh the dialog, change the current widget to keep the order
 264        of overlapped widgets. This is useful in multi-window editor.
 265        In general, menubar should be a special object, not an ordinary widget
 266        in the current dialog. */
 267     h = WIDGET (menubar)->owner;
 268     h->current = g_list_find (h->widgets, dlg_find_by_id (h, menubar->previous_widget));
 269
 270     menubar->is_dropped = FALSE;
 271     do_refresh ();
 272     menubar->is_dropped = TRUE;
 273
 274     /* restore current widget */
 275     h->current = g_list_find (h->widgets, menubar);
 276 }
 277
 278 /* --------------------------------------------------------------------------------------------- */
 279
 280 static void
 281 menubar_left (WMenuBar * menubar)
 282 {
 283     menubar_remove (menubar);
 284     if (menubar->selected == 0)
 285         menubar->selected = g_list_length (menubar->menu) - 1;
 286     else
 287         menubar->selected--;
 288     menubar_draw (menubar);
 289 }
 290
 291 /* --------------------------------------------------------------------------------------------- */
 292
 293 static void
 294 menubar_right (WMenuBar * menubar)
 295 {
 296     menubar_remove (menubar);
 297     menubar->selected = (menubar->selected + 1) % g_list_length (menubar->menu);
 298     menubar_draw (menubar);
 299 }
 300
 301 /* --------------------------------------------------------------------------------------------- */
 302
 303 static void
 304 menubar_finish (WMenuBar * menubar)
 305 {
 306     Widget *w = WIDGET (menubar);
 307
 308     menubar->is_dropped = FALSE;
 309     menubar->is_active = FALSE;
 310     w->lines = 1;
 311     widget_want_hotkey (w, 0);
 312
 313     dlg_select_by_id (w->owner, menubar->previous_widget);
 314     do_refresh ();
 315 }
 316
 317 /* --------------------------------------------------------------------------------------------- */
 318
 319 static void
 320 menubar_drop (WMenuBar * menubar, unsigned int selected)
 321 {
 322     menubar->is_dropped = TRUE;
 323     menubar->selected = selected;
 324     menubar_draw (menubar);
 325 }
 326
 327 /* --------------------------------------------------------------------------------------------- */
 328
 329 static void
 330 menubar_execute (WMenuBar * menubar)
 331 {
 332     const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 333     const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, menu->selected));
 334
 335     if ((entry != NULL) && (entry->command != CK_IgnoreKey))
 336     {
 337         Widget *w = WIDGET (menubar);
 338
 339         mc_global.widget.is_right = (menubar->selected != 0);
 340         menubar_finish (menubar);
 341         send_message (w->owner, w, MSG_ACTION, entry->command, NULL);
 342         do_refresh ();
 343     }
 344 }
 345
 346 /* --------------------------------------------------------------------------------------------- */
 347
 348 static void
 349 menubar_down (WMenuBar * menubar)
 350 {
 351     menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 352     const unsigned int len = g_list_length (menu->entries);
 353     menu_entry_t *entry;
 354
 355     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 356
 357     do
 358     {
 359         menu->selected = (menu->selected + 1) % len;
 360         entry = MENUENTRY (g_list_nth_data (menu->entries, menu->selected));
 361     }
 362     while ((entry == NULL) || (entry->command == CK_IgnoreKey));
 363
 364     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 365 }
 366
 367 /* --------------------------------------------------------------------------------------------- */
 368
 369 static void
 370 menubar_up (WMenuBar * menubar)
 371 {
 372     menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 373     const unsigned int len = g_list_length (menu->entries);
 374     menu_entry_t *entry;
 375
 376     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 377
 378     do
 379     {
 380         if (menu->selected == 0)
 381             menu->selected = len - 1;
 382         else
 383             menu->selected--;
 384         entry = MENUENTRY (g_list_nth_data (menu->entries, menu->selected));
 385     }
 386     while ((entry == NULL) || (entry->command == CK_IgnoreKey));
 387
 388     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 389 }
 390
 391 /* --------------------------------------------------------------------------------------------- */
 392
 393 static void
 394 menubar_first (WMenuBar * menubar)
 395 {
 396     menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 397
 398     if (menu->selected == 0)
 399         return;
 400
 401     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 402
 403     menu->selected = 0;
 404
 405     while (TRUE)
 406     {
 407         menu_entry_t *entry;
 408
 409         entry = MENUENTRY (g_list_nth_data (menu->entries, menu->selected));
 410
 411         if ((entry == NULL) || (entry->command == CK_IgnoreKey))
 412             menu->selected++;
 413         else
 414             break;
 415     }
 416
 417     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 418 }
 419
 420 /* --------------------------------------------------------------------------------------------- */
 421
 422 static void
 423 menubar_last (WMenuBar * menubar)
 424 {
 425     menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 426     const unsigned int len = g_list_length (menu->entries);
 427     menu_entry_t *entry;
 428
 429     if (menu->selected == len - 1)
 430         return;
 431
 432     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 433
 434     menu->selected = len;
 435
 436     do
 437     {
 438         menu->selected--;
 439         entry = MENUENTRY (g_list_nth_data (menu->entries, menu->selected));
 440     }
 441     while ((entry == NULL) || (entry->command == CK_IgnoreKey));
 442
 443     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 444 }
 445
 446 /* --------------------------------------------------------------------------------------------- */
 447
 448 static int
 449 menubar_handle_key (WMenuBar * menubar, int key)
 450 {
 451     /* Lowercase */
 452     if (isascii (key))
 453         key = g_ascii_tolower (key);
 454
 455     if (is_abort_char (key))
 456     {
 457         menubar_finish (menubar);
 458         return 1;
 459     }
 460
 461     /* menubar help or menubar navigation */
 462     switch (key)
 463     {
 464     case KEY_F (1):
 465         {
 466             ev_help_t event_data = { NULL, NULL };
 467
 468             if (menubar->is_dropped)
 469                 event_data.node =
 470                     MENU (g_list_nth_data (menubar->menu, menubar->selected))->help_node;
 471             else
 472                 event_data.node = "[Menu Bar]";
 473
 474             mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
 475             menubar_draw (menubar);
 476             return 1;
 477         }
 478
 479     case KEY_LEFT:
 480     case XCTRL ('b'):
 481         menubar_left (menubar);
 482         return 1;
 483
 484     case KEY_RIGHT:
 485     case XCTRL ('f'):
 486         menubar_right (menubar);
 487         return 1;
 488
 489     default:
 490         break;
 491     }
 492
 493     if (!menubar->is_dropped)
 494     {
 495         GList *i;
 496
 497         /* drop menu by hotkey */
 498         for (i = menubar->menu; i != NULL; i = g_list_next (i))
 499         {
 500             menu_t *menu = MENU (i->data);
 501
 502             if ((menu->text.hotkey != NULL) && (key == g_ascii_tolower (menu->text.hotkey[0])))
 503             {
 504                 menubar_drop (menubar, g_list_position (menubar->menu, i));
 505                 return 1;
 506             }
 507         }
 508
 509         /* drop menu by Enter or Dowwn key */
 510         if (key == KEY_ENTER || key == XCTRL ('n') || key == KEY_DOWN || key == '\n')
 511             menubar_drop (menubar, menubar->selected);
 512
 513         return 1;
 514     }
 515
 516     {
 517         menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 518         GList *i;
 519
 520         /* execute menu command by hotkey */
 521         for (i = menu->entries; i != NULL; i = g_list_next (i))
 522         {
 523             const menu_entry_t *entry = MENUENTRY (i->data);
 524
 525             if ((entry != NULL) && (entry->command != CK_IgnoreKey)
 526                 && (entry->text.hotkey != NULL) && (key == g_ascii_tolower (entry->text.hotkey[0])))
 527             {
 528                 menu->selected = g_list_position (menu->entries, i);
 529                 menubar_execute (menubar);
 530                 return 1;
 531             }
 532         }
 533
 534         /* menu execute by Enter or menu navigation */
 535         switch (key)
 536         {
 537         case KEY_ENTER:
 538         case '\n':
 539             menubar_execute (menubar);
 540             return 1;
 541
 542         case KEY_HOME:
 543         case ALT ('<'):
 544             menubar_first (menubar);
 545             break;
 546
 547         case KEY_END:
 548         case ALT ('>'):
 549             menubar_last (menubar);
 550             break;
 551
 552         case KEY_DOWN:
 553         case XCTRL ('n'):
 554             menubar_down (menubar);
 555             break;
 556
 557         case KEY_UP:
 558         case XCTRL ('p'):
 559             menubar_up (menubar);
 560             break;
 561
 562         default:
 563             break;
 564         }
 565     }
 566
 567     return 0;
 568 }
 569
 570 /* --------------------------------------------------------------------------------------------- */
 571
 572 static cb_ret_t
 573 menubar_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
 574 {
 575     WMenuBar *menubar = MENUBAR (w);
 576
 577     switch (msg)
 578     {
 579         /* We do not want the focus unless we have been activated */
 580     case MSG_FOCUS:
 581         if (!menubar->is_active)
 582             return MSG_NOT_HANDLED;
 583
 584         /* Trick to get all the mouse events */
 585         w->lines = LINES;
 586
 587         /* Trick to get all of the hotkeys */
 588         widget_want_hotkey (w, 1);
 589         menubar_draw (menubar);
 590         return MSG_HANDLED;
 591
 592         /* We don't want the buttonbar to activate while using the menubar */
 593     case MSG_HOTKEY:
 594     case MSG_KEY:
 595         if (menubar->is_active)
 596         {
 597             menubar_handle_key (menubar, parm);
 598             return MSG_HANDLED;
 599         }
 600         return MSG_NOT_HANDLED;
 601
 602     case MSG_CURSOR:
 603         /* Put the cursor in a suitable place */
 604         return MSG_NOT_HANDLED;
 605
 606     case MSG_UNFOCUS:
 607         return menubar->is_active ? MSG_NOT_HANDLED : MSG_HANDLED;
 608
 609     case MSG_DRAW:
 610         if (menubar->is_visible)
 611         {
 612             menubar_draw (menubar);
 613             return MSG_HANDLED;
 614         }
 615         /* fall through */
 616
 617     case MSG_RESIZE:
 618         /* try show menu after screen resize */
 619         send_message (w, sender, MSG_FOCUS, 0, data);
 620         return MSG_HANDLED;
 621
 622
 623     case MSG_DESTROY:
 624         menubar_set_menu (menubar, NULL);
 625         return MSG_HANDLED;
 626
 627     default:
 628         return widget_default_callback (w, sender, msg, parm, data);
 629     }
 630 }
 631
 632 /* --------------------------------------------------------------------------------------------- */
 633
 634 static int
 635 menubar_event (Gpm_Event * event, void *data)
 636 {
 637     WMenuBar *menubar = MENUBAR (data);
 638     Widget *w = WIDGET (data);
 639     gboolean was_active = TRUE;
 640     int left_x, right_x, bottom_y;
 641     menu_t *menu;
 642     Gpm_Event local;
 643
 644     if (!mouse_global_in_widget (event, w))
 645         return MOU_UNHANDLED;
 646
 647     /* ignore unsupported events */
 648     if ((event->type & (GPM_UP | GPM_DOWN | GPM_DRAG)) == 0)
 649         return MOU_NORMAL;
 650
 651     /* ignore wheel events if menu is inactive */
 652     if (!menubar->is_active && ((event->buttons & (GPM_B_MIDDLE | GPM_B_UP | GPM_B_DOWN)) != 0))
 653         return MOU_NORMAL;
 654
 655     local = mouse_get_local (event, w);
 656
 657     if (local.y == 1 && (local.type & GPM_UP) != 0)
 658         return MOU_NORMAL;
 659
 660     if (!menubar->is_dropped)
 661     {
 662         if (local.y > 1)
 663         {
 664             /* mouse click below menubar -- close menu and send focus to widget under mouse */
 665             menubar_finish (menubar);
 666             return MOU_UNHANDLED;
 667         }
 668
 669         menubar->previous_widget = dlg_get_current_widget_id (w->owner);
 670         menubar->is_active = TRUE;
 671         menubar->is_dropped = TRUE;
 672         was_active = FALSE;
 673     }
 674
 675     /* Mouse operations on the menubar */
 676     if (local.y == 1 || !was_active)
 677     {
 678         /* wheel events on menubar */
 679         if ((local.buttons & GPM_B_UP) != 0)
 680             menubar_left (menubar);
 681         else if ((local.buttons & GPM_B_DOWN) != 0)
 682             menubar_right (menubar);
 683         else
 684         {
 685             const unsigned int len = g_list_length (menubar->menu);
 686             unsigned int new_selection = 0;
 687
 688             while ((new_selection < len)
 689                    && (local.x > MENU (g_list_nth_data (menubar->menu, new_selection))->start_x))
 690                 new_selection++;
 691
 692             if (new_selection != 0)     /* Don't set the invalid value -1 */
 693                 new_selection--;
 694
 695             if (!was_active)
 696             {
 697                 menubar->selected = new_selection;
 698                 dlg_select_widget (menubar);
 699             }
 700             else
 701             {
 702                 menubar_remove (menubar);
 703                 menubar->selected = new_selection;
 704             }
 705             menubar_draw (menubar);
 706         }
 707         return MOU_NORMAL;
 708     }
 709
 710     if (!menubar->is_dropped || (local.y < 2))
 711         return MOU_NORMAL;
 712
 713     /* middle click -- everywhere */
 714     if (((local.buttons & GPM_B_MIDDLE) != 0) && ((local.type & GPM_DOWN) != 0))
 715     {
 716         menubar_execute (menubar);
 717         return MOU_NORMAL;
 718     }
 719
 720     /* the mouse operation is on the menus or it is not */
 721     menu = MENU (g_list_nth_data (menubar->menu, menubar->selected));
 722     left_x = menu->start_x;
 723     right_x = left_x + menu->max_entry_len + 3;
 724     if (right_x > w->cols)
 725     {
 726         left_x = w->cols - menu->max_entry_len - 3;
 727         right_x = w->cols;
 728     }
 729
 730     bottom_y = g_list_length (menu->entries) + 3;
 731
 732     if ((local.x >= left_x) && (local.x <= right_x) && (local.y <= bottom_y))
 733     {
 734         int pos = local.y - 3;
 735         const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, pos));
 736
 737         /* mouse wheel */
 738         if ((local.buttons & GPM_B_UP) != 0 && (local.type & GPM_DOWN) != 0)
 739         {
 740             menubar_up (menubar);
 741             return MOU_NORMAL;
 742         }
 743         if ((local.buttons & GPM_B_DOWN) != 0 && (local.type & GPM_DOWN) != 0)
 744         {
 745             menubar_down (menubar);
 746             return MOU_NORMAL;
 747         }
 748
 749         /* ignore events above and below dropped down menu */
 750         if ((pos < 0) || (pos >= bottom_y - 3))
 751             return MOU_NORMAL;
 752
 753         if ((entry != NULL) && (entry->command != CK_IgnoreKey))
 754         {
 755             menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 756             menu->selected = pos;
 757             menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 758
 759             if ((event->type & GPM_UP) != 0)
 760                 menubar_execute (menubar);
 761         }
 762     }
 763     else if (((local.type & GPM_DOWN) != 0) && ((local.buttons & (GPM_B_UP | GPM_B_DOWN)) == 0))
 764     {
 765         /* use click not wheel to close menu */
 766         menubar_finish (menubar);
 767     }
 768
 769     return MOU_NORMAL;
 770 }
 771
 772 /* --------------------------------------------------------------------------------------------- */
 773 /*** public functions ****************************************************************************/
 774 /* --------------------------------------------------------------------------------------------- */
 775
 776 menu_entry_t *
 777 menu_entry_create (const char *name, long command)
 778 {
 779     menu_entry_t *entry;
 780
 781     entry = g_new (menu_entry_t, 1);
 782     entry->first_letter = ' ';
 783     entry->text = parse_hotkey (name);
 784     entry->command = command;
 785     entry->shortcut = NULL;
 786
 787     return entry;
 788 }
 789
 790 /* --------------------------------------------------------------------------------------------- */
 791
 792 void
 793 menu_entry_free (menu_entry_t * entry)
 794 {
 795     if (entry != NULL)
 796     {
 797         release_hotkey (entry->text);
 798         g_free (entry->shortcut);
 799         g_free (entry);
 800     }
 801 }
 802
 803 /* --------------------------------------------------------------------------------------------- */
 804
 805 menu_t *
 806 create_menu (const char *name, GList * entries, const char *help_node)
 807 {
 808     menu_t *menu;
 809
 810     menu = g_new (menu_t, 1);
 811     menu->start_x = 0;
 812     menu->text = parse_hotkey (name);
 813     menu->entries = entries;
 814     menu->max_entry_len = 1;
 815     menu->max_hotkey_len = 0;
 816     menu->selected = 0;
 817     menu->help_node = g_strdup (help_node);
 818
 819     return menu;
 820 }
 821
 822 /* --------------------------------------------------------------------------------------------- */
 823
 824 void
 825 menu_set_name (menu_t * menu, const char *name)
 826 {
 827     release_hotkey (menu->text);
 828     menu->text = parse_hotkey (name);
 829 }
 830
 831 /* --------------------------------------------------------------------------------------------- */
 832
 833 void
 834 destroy_menu (menu_t * menu)
 835 {
 836     release_hotkey (menu->text);
 837     g_list_free_full (menu->entries, (GDestroyNotify) menu_entry_free);
 838     g_free (menu->help_node);
 839     g_free (menu);
 840 }
 841
 842 /* --------------------------------------------------------------------------------------------- */
 843
 844 WMenuBar *
 845 menubar_new (int y, int x, int cols, GList * menu, gboolean visible)
 846 {
 847     WMenuBar *menubar;
 848     Widget *w;
 849
 850     menubar = g_new0 (WMenuBar, 1);
 851     w = WIDGET (menubar);
 852     widget_init (w, y, x, 1, cols, menubar_callback, menubar_event);
 853
 854     menubar->is_visible = visible;
 855     widget_want_cursor (w, FALSE);
 856     menubar_set_menu (menubar, menu);
 857
 858     return menubar;
 859 }
 860
 861 /* --------------------------------------------------------------------------------------------- */
 862
 863 void
 864 menubar_set_menu (WMenuBar * menubar, GList * menu)
 865 {
 866     /* delete previous menu */
 867     if (menubar->menu != NULL)
 868         g_list_free_full (menubar->menu, (GDestroyNotify) destroy_menu);
 869
 870     /* add new menu */
 871     menubar->is_active = FALSE;
 872     menubar->is_dropped = FALSE;
 873     menubar->menu = menu;
 874     menubar->selected = 0;
 875     menubar_arrange (menubar);
 876 }
 877
 878 /* --------------------------------------------------------------------------------------------- */
 879
 880 void
 881 menubar_add_menu (WMenuBar * menubar, menu_t * menu)
 882 {
 883     if (menu != NULL)
 884     {
 885         menu_arrange (menu, WIDGET (menubar)->owner->get_shortcut);
 886         menubar->menu = g_list_append (menubar->menu, menu);
 887     }
 888
 889     menubar_arrange (menubar);
 890 }
 891
 892 /* --------------------------------------------------------------------------------------------- */
 893 /**
 894  * Properly space menubar items. Should be called when menubar is created
 895  * and also when widget width is changed (i.e. upon xterm resize).
 896  */
 897
 898 void
 899 menubar_arrange (WMenuBar * menubar)
 900 {
 901     int start_x = 1;
 902     GList *i;
 903     int gap;
 904
 905     if (menubar->menu == NULL)
 906         return;
 907
 908     gap = WIDGET (menubar)->cols - 2;
 909
 910     /* First, calculate gap between items... */
 911     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 912     {
 913         menu_t *menu = MENU (i->data);
 914
 915         /* preserve length here, to be used below */
 916         menu->start_x = hotkey_width (menu->text) + 2;
 917         gap -= menu->start_x;
 918     }
 919
 920     if (g_list_next (menubar->menu) == NULL)
 921         gap = 1;
 922     else
 923         gap /= (g_list_length (menubar->menu) - 1);
 924
 925     if (gap <= 0)
 926     {
 927         /* We are out of luck - window is too narrow... */
 928         gap = 1;
 929     }
 930     else if (gap >= 3)
 931         gap = 3;
 932
 933     /* ...and now fix start positions of menubar items */
 934     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 935     {
 936         menu_t *menu = MENU (i->data);
 937         int len = menu->start_x;
 938
 939         menu->start_x = start_x;
 940         start_x += len + gap;
 941     }
 942 }
 943
 944 /* --------------------------------------------------------------------------------------------- */
 945 /** Find MenuBar widget in the dialog */
 946
 947 WMenuBar *
 948 find_menubar (const WDialog * h)
 949 {
 950     return MENUBAR (find_widget_type (h, menubar_callback));
 951 }
 952
 953 /* --------------------------------------------------------------------------------------------- */