lib/widget/menu.c

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