src/menu.c

   1 /* Copyright (C) 1994, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   2    2007, 2009 Free Software Foundation, Inc.
   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 /** \file menu.c
  19  *  \brief Source: pulldown menu code
  20  */
  21
  22 #include <config.h>
  23
  24 #include <ctype.h>
  25 #include <stdarg.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28
  29 #include "lib/global.h"
  30
  31 #include "lib/tty/tty.h"
  32 #include "lib/skin.h"
  33 #include "lib/tty/mouse.h"
  34 #include "lib/tty/key.h"        /* key macros */
  35 #include "lib/strutil.h"
  36
  37 #include "cmddef.h"             /* CK_Ignore_Key */
  38 #include "help.h"
  39 #include "dialog.h"
  40 #include "widget.h"
  41 #include "main.h"               /* is_right */
  42 #include "menu.h"
  43
  44 int menubar_visible = 1;        /* This is the new default */
  45
  46 static cb_ret_t menubar_callback (Widget * w, widget_msg_t msg, int parm);
  47
  48 menu_entry_t *
  49 menu_entry_create (const char *name, unsigned long command)
  50 {
  51     menu_entry_t *entry;
  52
  53     entry = g_new (menu_entry_t, 1);
  54     entry->first_letter = ' ';
  55     entry->text = parse_hotkey (name);
  56     entry->command = command;
  57     entry->shortcut = NULL;
  58
  59     return entry;
  60 }
  61
  62 void
  63 menu_entry_free (menu_entry_t * entry)
  64 {
  65     if (entry != NULL)
  66     {
  67         release_hotkey (entry->text);
  68         g_free (entry->shortcut);
  69         g_free (entry);
  70     }
  71 }
  72
  73 static void
  74 menu_arrange (Menu * menu, dlg_shortcut_str get_shortcut)
  75 {
  76     if (menu != NULL)
  77     {
  78         GList *i;
  79         size_t max_shortcut_len = 0;
  80
  81         menu->max_entry_len = 1;
  82         menu->max_hotkey_len = 1;
  83
  84         for (i = menu->entries; i != NULL; i = g_list_next (i))
  85         {
  86             menu_entry_t *entry = i->data;
  87
  88             if (entry != NULL)
  89             {
  90                 size_t len;
  91
  92                 len = (size_t) hotkey_width (entry->text);
  93                 menu->max_hotkey_len = max (menu->max_hotkey_len, len);
  94
  95                 if (get_shortcut != NULL)
  96                     entry->shortcut = get_shortcut (entry->command);
  97
  98                 if (entry->shortcut != NULL)
  99                 {
 100                     len = (size_t) str_term_width1 (entry->shortcut);
 101                     max_shortcut_len = max (max_shortcut_len, len);
 102                 }
 103             }
 104         }
 105
 106         menu->max_entry_len = menu->max_hotkey_len + max_shortcut_len;
 107     }
 108 }
 109
 110 Menu *
 111 create_menu (const char *name, GList * entries, const char *help_node)
 112 {
 113     Menu *menu;
 114
 115     menu = g_new (Menu, 1);
 116     menu->start_x = 0;
 117     menu->text = parse_hotkey (name);
 118     menu->entries = entries;
 119     menu->max_entry_len = 1;
 120     menu->max_hotkey_len = 0;
 121     menu->selected = 0;
 122     menu->help_node = g_strdup (help_node);
 123
 124     return menu;
 125 }
 126
 127 void
 128 destroy_menu (Menu * menu)
 129 {
 130     release_hotkey (menu->text);
 131     g_list_foreach (menu->entries, (GFunc) menu_entry_free, NULL);
 132     g_list_free (menu->entries);
 133     g_free (menu->help_node);
 134     g_free (menu);
 135 }
 136
 137 static void
 138 menubar_paint_idx (WMenuBar * menubar, unsigned int idx, int color)
 139 {
 140     const Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 141     const menu_entry_t *entry = g_list_nth_data (menu->entries, idx);
 142     const int y = 2 + idx;
 143     int x = menu->start_x;
 144
 145     if (x + menu->max_entry_len + 4 > (gsize) menubar->widget.cols)
 146         x = menubar->widget.cols - menu->max_entry_len - 4;
 147
 148     if (entry == NULL)
 149     {
 150         /* menu separator */
 151         tty_setcolor (MENU_ENTRY_COLOR);
 152
 153         widget_move (&menubar->widget, y, x - 1);
 154         tty_print_alt_char (ACS_LTEE, FALSE);
 155
 156         tty_draw_hline (menubar->widget.y + y, menubar->widget.x + x,
 157                         ACS_HLINE, menu->max_entry_len + 3);
 158
 159         widget_move (&menubar->widget, y, x + menu->max_entry_len + 3);
 160         tty_print_alt_char (ACS_RTEE, FALSE);
 161     }
 162     else
 163     {
 164         /* menu text */
 165         tty_setcolor (color);
 166         widget_move (&menubar->widget, y, x);
 167         tty_print_char ((unsigned char) entry->first_letter);
 168         tty_draw_hline (-1, -1, ' ', menu->max_entry_len + 2);  /* clear line */
 169         tty_print_string (entry->text.start);
 170
 171         if (entry->text.hotkey != NULL)
 172         {
 173             tty_setcolor (color == MENU_SELECTED_COLOR ? MENU_HOTSEL_COLOR : MENU_HOT_COLOR);
 174             tty_print_string (entry->text.hotkey);
 175             tty_setcolor (color);
 176         }
 177
 178         if (entry->text.end != NULL)
 179             tty_print_string (entry->text.end);
 180
 181         if (entry->shortcut != NULL)
 182         {
 183             widget_move (&menubar->widget, y, x + menu->max_hotkey_len + 3);
 184             tty_print_string (entry->shortcut);
 185         }
 186
 187         /* move cursor to the start of entry text */
 188         widget_move (&menubar->widget, y, x + 1);
 189     }
 190 }
 191
 192 static void
 193 menubar_draw_drop (WMenuBar * menubar)
 194 {
 195     const Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 196     const unsigned int count = g_list_length (menu->entries);
 197     int column = menu->start_x - 1;
 198     unsigned int i;
 199
 200     if (column + menu->max_entry_len + 5 > (gsize) menubar->widget.cols)
 201         column = menubar->widget.cols - menu->max_entry_len - 5;
 202
 203     tty_setcolor (MENU_ENTRY_COLOR);
 204     draw_box (menubar->widget.owner,
 205               menubar->widget.y + 1, menubar->widget.x + column,
 206               count + 2, menu->max_entry_len + 5, FALSE);
 207
 208     for (i = 0; i < count; i++)
 209         menubar_paint_idx (menubar, i,
 210                            i == menu->selected ? MENU_SELECTED_COLOR : MENU_ENTRY_COLOR);
 211 }
 212
 213 static void
 214 menubar_set_color (WMenuBar * menubar, gboolean current, gboolean hotkey)
 215 {
 216     if (!menubar->is_active)
 217         tty_setcolor (MENU_INACTIVE_COLOR);
 218     else if (current)
 219         tty_setcolor (hotkey ? MENU_HOTSEL_COLOR : MENU_SELECTED_COLOR);
 220     else
 221         tty_setcolor (hotkey ? MENU_HOT_COLOR : MENU_ENTRY_COLOR);
 222 }
 223
 224 static void
 225 menubar_draw (WMenuBar * menubar)
 226 {
 227     GList *i;
 228
 229     /* First draw the complete menubar */
 230     tty_setcolor (menubar->is_active ? MENU_ENTRY_COLOR : MENU_INACTIVE_COLOR);
 231     tty_draw_hline (menubar->widget.y, menubar->widget.x, ' ', menubar->widget.cols);
 232
 233     /* Now each one of the entries */
 234     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 235     {
 236         Menu *menu = i->data;
 237         gboolean is_selected = (menubar->selected == (gsize) g_list_position (menubar->menu, i));
 238
 239         menubar_set_color (menubar, is_selected, FALSE);
 240         widget_move (&menubar->widget, 0, menu->start_x);
 241
 242         tty_print_char (' ');
 243         tty_print_string (menu->text.start);
 244
 245         if (menu->text.hotkey != NULL)
 246         {
 247             menubar_set_color (menubar, is_selected, TRUE);
 248             tty_print_string (menu->text.hotkey);
 249             menubar_set_color (menubar, is_selected, FALSE);
 250         }
 251
 252         if (menu->text.end != NULL)
 253             tty_print_string (menu->text.end);
 254
 255         tty_print_char (' ');
 256     }
 257
 258     if (menubar->is_dropped)
 259         menubar_draw_drop (menubar);
 260     else
 261         widget_move (&menubar->widget, 0,
 262                      ((Menu *) g_list_nth_data (menubar->menu, menubar->selected))->start_x);
 263 }
 264
 265 static void
 266 menubar_remove (WMenuBar * menubar)
 267 {
 268     if (menubar->is_dropped)
 269     {
 270         menubar->is_dropped = FALSE;
 271         do_refresh ();
 272         menubar->is_dropped = TRUE;
 273     }
 274 }
 275
 276 static void
 277 menubar_left (WMenuBar * menubar)
 278 {
 279     menubar_remove (menubar);
 280     if (menubar->selected == 0)
 281         menubar->selected = g_list_length (menubar->menu) - 1;
 282     else
 283         menubar->selected--;
 284     menubar_draw (menubar);
 285 }
 286
 287 static void
 288 menubar_right (WMenuBar * menubar)
 289 {
 290     menubar_remove (menubar);
 291     menubar->selected = (menubar->selected + 1) % g_list_length (menubar->menu);
 292     menubar_draw (menubar);
 293 }
 294
 295 static void
 296 menubar_finish (WMenuBar * menubar)
 297 {
 298     menubar->is_dropped = FALSE;
 299     menubar->is_active = FALSE;
 300     menubar->widget.lines = 1;
 301     widget_want_hotkey (menubar->widget, 0);
 302
 303     dlg_select_by_id (menubar->widget.owner, menubar->previous_widget);
 304     do_refresh ();
 305 }
 306
 307 static void
 308 menubar_drop (WMenuBar * menubar, unsigned int selected)
 309 {
 310     menubar->is_dropped = TRUE;
 311     menubar->selected = selected;
 312     menubar_draw (menubar);
 313 }
 314
 315 static void
 316 menubar_execute (WMenuBar * menubar)
 317 {
 318     const Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 319     const menu_entry_t *entry = g_list_nth_data (menu->entries, menu->selected);
 320
 321     if ((entry != NULL) && (entry->command != CK_Ignore_Key))
 322     {
 323         is_right = (menubar->selected != 0);
 324         menubar_finish (menubar);
 325         menubar->widget.owner->callback (menubar->widget.owner, &menubar->widget,
 326                                          DLG_ACTION, entry->command, NULL);
 327         do_refresh ();
 328     }
 329 }
 330
 331 static void
 332 menubar_down (WMenuBar * menubar)
 333 {
 334     Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 335     const unsigned int len = g_list_length (menu->entries);
 336     menu_entry_t *entry;
 337
 338     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 339
 340     do
 341     {
 342         menu->selected = (menu->selected + 1) % len;
 343         entry = (menu_entry_t *) g_list_nth_data (menu->entries, menu->selected);
 344     }
 345     while ((entry == NULL) || (entry->command == CK_Ignore_Key));
 346
 347     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 348 }
 349
 350 static void
 351 menubar_up (WMenuBar * menubar)
 352 {
 353     Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 354     const unsigned int len = g_list_length (menu->entries);
 355     menu_entry_t *entry;
 356
 357     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 358
 359     do
 360     {
 361         if (menu->selected == 0)
 362             menu->selected = len - 1;
 363         else
 364             menu->selected--;
 365         entry = (menu_entry_t *) g_list_nth_data (menu->entries, menu->selected);
 366     }
 367     while ((entry == NULL) || (entry->command == CK_Ignore_Key));
 368
 369     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 370 }
 371
 372 static void
 373 menubar_first (WMenuBar * menubar)
 374 {
 375     Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 376     menu_entry_t *entry;
 377
 378     if (menu->selected == 0)
 379         return;
 380
 381     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 382
 383     menu->selected = 0;
 384
 385     while (TRUE)
 386     {
 387         entry = (menu_entry_t *) g_list_nth_data (menu->entries, menu->selected);
 388
 389         if ((entry == NULL) || (entry->command == CK_Ignore_Key))
 390             menu->selected++;
 391         else
 392             break;
 393     }
 394
 395     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 396 }
 397
 398 static void
 399 menubar_last (WMenuBar * menubar)
 400 {
 401     Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 402     const unsigned int len = g_list_length (menu->entries);
 403     menu_entry_t *entry;
 404
 405     if (menu->selected == len - 1)
 406         return;
 407
 408     menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 409
 410     menu->selected = len;
 411
 412     do
 413     {
 414         menu->selected--;
 415         entry = (menu_entry_t *) g_list_nth_data (menu->entries, menu->selected);
 416     }
 417     while ((entry == NULL) || (entry->command == CK_Ignore_Key));
 418
 419     menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 420 }
 421
 422 static int
 423 menubar_handle_key (WMenuBar * menubar, int key)
 424 {
 425     /* Lowercase */
 426     if (isascii (key))
 427         key = g_ascii_tolower (key);
 428
 429     if (is_abort_char (key))
 430     {
 431         menubar_finish (menubar);
 432         return 1;
 433     }
 434
 435     /* menubar help or menubar navigation */
 436     switch (key)
 437     {
 438     case KEY_F (1):
 439         if (menubar->is_dropped)
 440             interactive_display (NULL,
 441                                  ((Menu *) g_list_nth_data (menubar->menu,
 442                                                             menubar->selected))->help_node);
 443         else
 444             interactive_display (NULL, "[Menu Bar]");
 445         menubar_draw (menubar);
 446         return 1;
 447
 448     case KEY_LEFT:
 449     case XCTRL ('b'):
 450         menubar_left (menubar);
 451         return 1;
 452
 453     case KEY_RIGHT:
 454     case XCTRL ('f'):
 455         menubar_right (menubar);
 456         return 1;
 457     }
 458
 459     if (!menubar->is_dropped)
 460     {
 461         GList *i;
 462
 463         /* drop menu by hotkey */
 464         for (i = menubar->menu; i != NULL; i = g_list_next (i))
 465         {
 466             Menu *menu = i->data;
 467
 468             if ((menu->text.hotkey != NULL) && (key == g_ascii_tolower (menu->text.hotkey[0])))
 469             {
 470                 menubar_drop (menubar, g_list_position (menubar->menu, i));
 471                 return 1;
 472             }
 473         }
 474
 475         /* drop menu by Enter or Dowwn key */
 476         if (key == KEY_ENTER || key == XCTRL ('n') || key == KEY_DOWN || key == '\n')
 477             menubar_drop (menubar, menubar->selected);
 478
 479         return 1;
 480     }
 481
 482     {
 483         Menu *menu = g_list_nth_data (menubar->menu, menubar->selected);
 484         GList *i;
 485
 486         /* execute menu command by hotkey */
 487         for (i = menu->entries; i != NULL; i = g_list_next (i))
 488         {
 489             const menu_entry_t *entry = i->data;
 490
 491             if ((entry != NULL) && (entry->command != CK_Ignore_Key)
 492                 && (entry->text.hotkey != NULL) && (key == g_ascii_tolower (entry->text.hotkey[0])))
 493             {
 494                 menu->selected = g_list_position (menu->entries, i);
 495                 menubar_execute (menubar);
 496                 return 1;
 497             }
 498         }
 499
 500         /* menu execute by Enter or menu navigation */
 501         switch (key)
 502         {
 503         case KEY_ENTER:
 504         case '\n':
 505             menubar_execute (menubar);
 506             return 1;
 507
 508         case KEY_HOME:
 509         case ALT ('<'):
 510             menubar_first (menubar);
 511             break;
 512
 513         case KEY_END:
 514         case ALT ('>'):
 515             menubar_last (menubar);
 516             break;
 517
 518         case KEY_DOWN:
 519         case XCTRL ('n'):
 520             menubar_down (menubar);
 521             break;
 522
 523         case KEY_UP:
 524         case XCTRL ('p'):
 525             menubar_up (menubar);
 526             break;
 527         }
 528     }
 529
 530     return 0;
 531 }
 532
 533 static cb_ret_t
 534 menubar_callback (Widget * w, widget_msg_t msg, int parm)
 535 {
 536     WMenuBar *menubar = (WMenuBar *) w;
 537
 538     switch (msg)
 539     {
 540         /* We do not want the focus unless we have been activated */
 541     case WIDGET_FOCUS:
 542         if (!menubar->is_active)
 543             return MSG_NOT_HANDLED;
 544
 545         /* Trick to get all the mouse events */
 546         menubar->widget.lines = LINES;
 547
 548         /* Trick to get all of the hotkeys */
 549         widget_want_hotkey (menubar->widget, 1);
 550         menubar_draw (menubar);
 551         return MSG_HANDLED;
 552
 553         /* We don't want the buttonbar to activate while using the menubar */
 554     case WIDGET_HOTKEY:
 555     case WIDGET_KEY:
 556         if (menubar->is_active)
 557         {
 558             menubar_handle_key (menubar, parm);
 559             return MSG_HANDLED;
 560         }
 561         return MSG_NOT_HANDLED;
 562
 563     case WIDGET_CURSOR:
 564         /* Put the cursor in a suitable place */
 565         return MSG_NOT_HANDLED;
 566
 567     case WIDGET_UNFOCUS:
 568         return menubar->is_active ? MSG_NOT_HANDLED : MSG_HANDLED;
 569
 570     case WIDGET_DRAW:
 571         if (menubar_visible)
 572         {
 573             menubar_draw (menubar);
 574             return MSG_HANDLED;
 575         }
 576         /* fall through */
 577
 578     case WIDGET_RESIZED:
 579         /* try show menu after screen resize */
 580         send_message (w, WIDGET_FOCUS, 0);
 581         return MSG_HANDLED;
 582
 583
 584     case WIDGET_DESTROY:
 585         menubar_set_menu (menubar, NULL);
 586         return MSG_HANDLED;
 587
 588     default:
 589         return default_proc (msg, parm);
 590     }
 591 }
 592
 593 static int
 594 menubar_event (Gpm_Event * event, void *data)
 595 {
 596     WMenuBar *menubar = data;
 597     gboolean was_active = TRUE;
 598     int left_x, right_x, bottom_y;
 599     Menu *menu;
 600
 601     /* ignore unsupported events */
 602     if ((event->type & (GPM_UP | GPM_DOWN | GPM_DRAG)) == 0)
 603         return MOU_NORMAL;
 604
 605     /* ignore wheel events if menu is inactive */
 606     if (!menubar->is_active && ((event->buttons & (GPM_B_MIDDLE | GPM_B_UP | GPM_B_DOWN)) != 0))
 607         return MOU_NORMAL;
 608
 609     if (!menubar->is_dropped)
 610     {
 611         menubar->previous_widget = dlg_get_current_widget_id (menubar->widget.owner);
 612         menubar->is_active = TRUE;
 613         menubar->is_dropped = TRUE;
 614         was_active = FALSE;
 615     }
 616
 617     /* Mouse operations on the menubar */
 618     if (event->y == 1 || !was_active)
 619     {
 620         if ((event->type & GPM_UP) != 0)
 621             return MOU_NORMAL;
 622
 623         /* wheel events on menubar */
 624         if (event->buttons & GPM_B_UP)
 625             menubar_left (menubar);
 626         else if (event->buttons & GPM_B_DOWN)
 627             menubar_right (menubar);
 628         else
 629         {
 630             const unsigned int len = g_list_length (menubar->menu);
 631             unsigned int new_selection = 0;
 632
 633             while ((new_selection < len)
 634                    && (event->x > ((Menu *) g_list_nth_data (menubar->menu,
 635                                                              new_selection))->start_x))
 636                 new_selection++;
 637
 638             if (new_selection != 0)     /* Don't set the invalid value -1 */
 639                 new_selection--;
 640
 641             if (!was_active)
 642             {
 643                 menubar->selected = new_selection;
 644                 dlg_select_widget (menubar);
 645             }
 646             else
 647             {
 648                 menubar_remove (menubar);
 649                 menubar->selected = new_selection;
 650             }
 651             menubar_draw (menubar);
 652         }
 653         return MOU_NORMAL;
 654     }
 655
 656     if (!menubar->is_dropped || (event->y < 2))
 657         return MOU_NORMAL;
 658
 659     /* middle click -- everywhere */
 660     if (((event->buttons & GPM_B_MIDDLE) != 0) && ((event->type & GPM_DOWN) != 0))
 661     {
 662         menubar_execute (menubar);
 663         return MOU_NORMAL;
 664     }
 665
 666     /* the mouse operation is on the menus or it is not */
 667     menu = (Menu *) g_list_nth_data (menubar->menu, menubar->selected);
 668     left_x = menu->start_x;
 669     right_x = left_x + menu->max_entry_len + 3;
 670     if (right_x > menubar->widget.cols)
 671     {
 672         left_x = menubar->widget.cols - menu->max_entry_len - 3;
 673         right_x = menubar->widget.cols;
 674     }
 675
 676     bottom_y = g_list_length (menu->entries) + 3;
 677
 678     if ((event->x >= left_x) && (event->x <= right_x) && (event->y <= bottom_y))
 679     {
 680         int pos = event->y - 3;
 681         const menu_entry_t *entry = g_list_nth_data (menu->entries, pos);
 682
 683         /* mouse wheel */
 684         if ((event->buttons & GPM_B_UP) && (event->type & GPM_DOWN))
 685         {
 686             menubar_up (menubar);
 687             return MOU_NORMAL;
 688         }
 689         if ((event->buttons & GPM_B_DOWN) && (event->type & GPM_DOWN))
 690         {
 691             menubar_down (menubar);
 692             return MOU_NORMAL;
 693         }
 694
 695         /* ignore events above and below dropped down menu */
 696         if ((pos < 0) || (pos >= bottom_y - 3))
 697             return MOU_NORMAL;
 698
 699         if ((entry != NULL) && (entry->command != CK_Ignore_Key))
 700         {
 701             menubar_paint_idx (menubar, menu->selected, MENU_ENTRY_COLOR);
 702             menu->selected = pos;
 703             menubar_paint_idx (menubar, menu->selected, MENU_SELECTED_COLOR);
 704
 705             if ((event->type & GPM_UP) != 0)
 706                 menubar_execute (menubar);
 707         }
 708     }
 709     else
 710         /* use click not wheel to close menu */
 711     if (((event->type & GPM_DOWN) != 0) && ((event->buttons & (GPM_B_UP | GPM_B_DOWN)) == 0))
 712         menubar_finish (menubar);
 713
 714     return MOU_NORMAL;
 715 }
 716
 717 WMenuBar *
 718 menubar_new (int y, int x, int cols, GList * menu)
 719 {
 720     WMenuBar *menubar = g_new0 (WMenuBar, 1);
 721
 722     init_widget (&menubar->widget, y, x, 1, cols, menubar_callback, menubar_event);
 723     widget_want_cursor (menubar->widget, 0);
 724     menubar_set_menu (menubar, menu);
 725     return menubar;
 726 }
 727
 728 void
 729 menubar_set_menu (WMenuBar * menubar, GList * menu)
 730 {
 731     /* delete previous menu */
 732     if (menubar->menu != NULL)
 733     {
 734         g_list_foreach (menubar->menu, (GFunc) destroy_menu, NULL);
 735         g_list_free (menubar->menu);
 736     }
 737     /* add new menu */
 738     menubar->is_active = FALSE;
 739     menubar->is_dropped = FALSE;
 740     menubar->menu = menu;
 741     menubar->selected = 0;
 742     menubar_arrange (menubar);
 743 }
 744
 745 void
 746 menubar_add_menu (WMenuBar * menubar, Menu * menu)
 747 {
 748     if (menu != NULL)
 749     {
 750         menu_arrange (menu, menubar->widget.owner->get_shortcut);
 751         menubar->menu = g_list_append (menubar->menu, menu);
 752     }
 753
 754     menubar_arrange (menubar);
 755 }
 756
 757 /*
 758  * Properly space menubar items. Should be called when menubar is created
 759  * and also when widget width is changed (i.e. upon xterm resize).
 760  */
 761 void
 762 menubar_arrange (WMenuBar * menubar)
 763 {
 764     int start_x = 1;
 765     GList *i;
 766     int gap;
 767
 768     if (menubar->menu == NULL)
 769         return;
 770
 771 #ifndef RESIZABLE_MENUBAR
 772     gap = 3;
 773
 774     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 775     {
 776         Menu *menu = i->data;
 777         int len = hotkey_width (menu->text) + 2;
 778
 779         menu->start_x = start_x;
 780         start_x += len + gap;
 781     }
 782 #else /* RESIZABLE_MENUBAR */
 783     gap = menubar->widget.cols - 2;
 784
 785     /* First, calculate gap between items... */
 786     for (i = menubar->menu; i != NULL; i = g_list_nwxt (i))
 787     {
 788         Menu *menu = i->data;
 789         /* preserve length here, to be used below */
 790         menu->start_x = hotkey_width (menu->text) + 2;
 791         gap -= menu->start_x;
 792     }
 793
 794     gap /= (menubar->menu->len - 1);
 795
 796     if (gap <= 0)
 797     {
 798         /* We are out of luck - window is too narrow... */
 799         gap = 1;
 800     }
 801
 802     /* ...and now fix start positions of menubar items */
 803     for (i = menubar->menu; i != NULL; i = g_list_nwxt (i))
 804     {
 805         Menu *menu = i->data;
 806         int len = menu->start_x;
 807
 808         menu->start_x = start_x;
 809         start_x += len + gap;
 810     }
 811 #endif /* RESIZABLE_MENUBAR */
 812 }
 813
 814 /* Find MenuBar widget in the dialog */
 815 WMenuBar *
 816 find_menubar (const Dlg_head * h)
 817 {
 818     return (WMenuBar *) find_widget_type (h, menubar_callback);
 819 }