lib/widget/menu.c

lib/widget/menu.c
/* */
This source file includes following definitions.
menu_arrange
menubar_paint_idx
menubar_draw_drop
menubar_set_color
menubar_draw
menubar_remove
menubar_left
menubar_right
menubar_finish
menubar_drop
menubar_execute
menubar_down
menubar_up
menubar_first
menubar_last
menubar_try_drop_menu
menubar_try_exec_menu
menubar_help
menubar_execute_cmd
menubar_handle_key
menubar_refresh
menubar_free_menu
menubar_callback
menubar_get_menu_by_x_coord
menubar_mouse_on_menu
menubar_change_selected_item
menubar_mouse_callback
menu_entry_new
menu_entry_free
menu_new
menu_set_name
menu_free
menubar_new
menubar_set_menu
menubar_add_menu
menubar_arrange
menubar_find
menubar_activate
   1 /*
   2    Pulldown menu code
   3 
   4    Copyright (C) 1994-2024
   5    Free Software Foundation, Inc.
   6 
   7    Written by:
   8    Andrew Borodin <aborodin@vmail.ru>, 2012-2022
   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/key.h"        /* key macros */
  42 #include "lib/strutil.h"
  43 #include "lib/widget.h"
  44 #include "lib/event.h"          /* mc_event_raise() */
  45 
  46 /*** global variables ****************************************************************************/
  47 
  48 const global_keymap_t *menu_map = NULL;
  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     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 current;       /* pointer to current menu entry */
  73     char *help_node;
  74 };
  75 
  76 /*** forward declarations (file scope functions) *************************************************/
  77 
  78 /*** file scope variables ************************************************************************/
  79 
  80 /* --------------------------------------------------------------------------------------------- */
  81 /*** file scope functions ************************************************************************/
  82 /* --------------------------------------------------------------------------------------------- */
  83 
  84 static void
  85 menu_arrange (menu_t * menu, dlg_shortcut_str get_shortcut)
     /*   */
  86 {
  87     if (menu != NULL)
  88     {
  89         GList *i;
  90         size_t max_shortcut_len = 0;
  91 
  92         menu->max_entry_len = 1;
  93         menu->max_hotkey_len = 1;
  94 
  95         for (i = menu->entries; i != NULL; i = g_list_next (i))
  96         {
  97             menu_entry_t *entry = MENUENTRY (i->data);
  98 
  99             if (entry != NULL)
 100             {
 101                 size_t len;
 102 
 103                 len = (size_t) hotkey_width (entry->text);
 104                 menu->max_hotkey_len = MAX (menu->max_hotkey_len, len);
 105 
 106                 if (get_shortcut != NULL)
 107                     entry->shortcut = get_shortcut (entry->command);
 108 
 109                 if (entry->shortcut != NULL)
 110                 {
 111                     len = (size_t) str_term_width1 (entry->shortcut);
 112                     max_shortcut_len = MAX (max_shortcut_len, len);
 113                 }
 114             }
 115         }
 116 
 117         menu->max_entry_len = menu->max_hotkey_len + max_shortcut_len;
 118     }
 119 }
 120 
 121 /* --------------------------------------------------------------------------------------------- */
 122 
 123 static void
 124 menubar_paint_idx (const WMenuBar * menubar, unsigned int idx, int color)
     /*   */
 125 {
 126     const WRect *w = &CONST_WIDGET (menubar)->rect;
 127     const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 128     const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, idx));
 129     const int y = 2 + idx;
 130     int x = menu->start_x;
 131 
 132     if (x + menu->max_entry_len + 4 > (gsize) w->cols)
 133         x = w->cols - menu->max_entry_len - 4;
 134 
 135     if (entry == NULL)
 136     {
 137         /* menu separator */
 138         tty_setcolor (MENU_ENTRY_COLOR);
 139 
 140         widget_gotoyx (menubar, y, x - 1);
 141         tty_print_alt_char (ACS_LTEE, FALSE);
 142         tty_draw_hline (w->y + y, w->x + x, ACS_HLINE, menu->max_entry_len + 3);
 143         widget_gotoyx (menubar, y, x + menu->max_entry_len + 3);
 144         tty_print_alt_char (ACS_RTEE, FALSE);
 145     }
 146     else
 147     {
 148         int yt, xt;
 149 
 150         /* menu text */
 151         tty_setcolor (color);
 152         widget_gotoyx (menubar, y, x);
 153         tty_print_char ((unsigned char) entry->first_letter);
 154         tty_getyx (&yt, &xt);
 155         tty_draw_hline (yt, xt, ' ', menu->max_entry_len + 2);  /* clear line */
 156         tty_print_string (entry->text.start);
 157 
 158         if (entry->text.hotkey != NULL)
 159         {
 160             tty_setcolor (color == MENU_SELECTED_COLOR ? MENU_HOTSEL_COLOR : MENU_HOT_COLOR);
 161             tty_print_string (entry->text.hotkey);
 162             tty_setcolor (color);
 163         }
 164 
 165         if (entry->text.end != NULL)
 166             tty_print_string (entry->text.end);
 167 
 168         if (entry->shortcut != NULL)
 169         {
 170             widget_gotoyx (menubar, y, x + menu->max_hotkey_len + 3);
 171             tty_print_string (entry->shortcut);
 172         }
 173 
 174         /* move cursor to the start of entry text */
 175         widget_gotoyx (menubar, y, x + 1);
 176     }
 177 }
 178 
 179 /* --------------------------------------------------------------------------------------------- */
 180 
 181 static void
 182 menubar_draw_drop (const WMenuBar * menubar)
     /*   */
 183 {
 184     const WRect *w = &CONST_WIDGET (menubar)->rect;
 185     const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 186     const unsigned int count = g_list_length (menu->entries);
 187     int column = menu->start_x - 1;
 188     unsigned int i;
 189 
 190     if (column + menu->max_entry_len + 5 > (gsize) w->cols)
 191         column = w->cols - menu->max_entry_len - 5;
 192 
 193     if (mc_global.tty.shadows)
 194         tty_draw_box_shadow (w->y + 1, w->x + column, count + 2, menu->max_entry_len + 5,
 195                              SHADOW_COLOR);
 196 
 197     tty_setcolor (MENU_ENTRY_COLOR);
 198     tty_draw_box (w->y + 1, w->x + column, count + 2, menu->max_entry_len + 5, FALSE);
 199 
 200     for (i = 0; i < count; i++)
 201         menubar_paint_idx (menubar, i, i == menu->current ? MENU_SELECTED_COLOR : MENU_ENTRY_COLOR);
 202 }
 203 
 204 /* --------------------------------------------------------------------------------------------- */
 205 
 206 static void
 207 menubar_set_color (const WMenuBar * menubar, gboolean current, gboolean hotkey)
     /*   */
 208 {
 209     if (!widget_get_state (CONST_WIDGET (menubar), WST_FOCUSED))
 210         tty_setcolor (MENU_INACTIVE_COLOR);
 211     else if (current)
 212         tty_setcolor (hotkey ? MENU_HOTSEL_COLOR : MENU_SELECTED_COLOR);
 213     else
 214         tty_setcolor (hotkey ? MENU_HOT_COLOR : MENU_ENTRY_COLOR);
 215 }
 216 
 217 /* --------------------------------------------------------------------------------------------- */
 218 
 219 static void
 220 menubar_draw (const WMenuBar * menubar)
     /*   */
 221 {
 222     const WRect *w = &CONST_WIDGET (menubar)->rect;
 223     GList *i;
 224 
 225     /* First draw the complete menubar */
 226     tty_setcolor (widget_get_state (WIDGET (menubar), WST_FOCUSED) ? MENU_ENTRY_COLOR :
 227                   MENU_INACTIVE_COLOR);
 228     tty_draw_hline (w->y, w->x, ' ', w->cols);
 229 
 230     /* Now each one of the entries */
 231     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 232     {
 233         menu_t *menu = MENU (i->data);
 234         gboolean is_selected = (menubar->current == (gsize) g_list_position (menubar->menu, i));
 235 
 236         menubar_set_color (menubar, is_selected, FALSE);
 237         widget_gotoyx (menubar, 0, menu->start_x);
 238 
 239         tty_print_char (' ');
 240         tty_print_string (menu->text.start);
 241 
 242         if (menu->text.hotkey != NULL)
 243         {
 244             menubar_set_color (menubar, is_selected, TRUE);
 245             tty_print_string (menu->text.hotkey);
 246             menubar_set_color (menubar, is_selected, FALSE);
 247         }
 248 
 249         if (menu->text.end != NULL)
 250             tty_print_string (menu->text.end);
 251 
 252         tty_print_char (' ');
 253     }
 254 
 255     if (menubar->is_dropped)
 256         menubar_draw_drop (menubar);
 257     else
 258         widget_gotoyx (menubar, 0,
 259                        MENU (g_list_nth_data (menubar->menu, menubar->current))->start_x);
 260 }
 261 
 262 /* --------------------------------------------------------------------------------------------- */
 263 
 264 static void
 265 menubar_remove (WMenuBar * menubar)
     /*   */
 266 {
 267     Widget *g;
 268 
 269     if (!menubar->is_dropped)
 270         return;
 271 
 272     /* HACK: before refresh the dialog, change the current widget to keep the order
 273        of overlapped widgets. This is useful in multi-window editor.
 274        In general, menubar should be a special object, not an ordinary widget
 275        in the current dialog. */
 276     g = WIDGET (WIDGET (menubar)->owner);
 277     GROUP (g)->current = widget_find (g, widget_find_by_id (g, menubar->previous_widget));
 278 
 279     menubar->is_dropped = FALSE;
 280     do_refresh ();
 281     menubar->is_dropped = TRUE;
 282 
 283     /* restore current widget */
 284     GROUP (g)->current = widget_find (g, WIDGET (menubar));
 285 }
 286 
 287 /* --------------------------------------------------------------------------------------------- */
 288 
 289 static void
 290 menubar_left (WMenuBar * menubar)
     /*   */
 291 {
 292     menubar_remove (menubar);
 293     if (menubar->current == 0)
 294         menubar->current = g_list_length (menubar->menu) - 1;
 295     else
 296         menubar->current--;
 297     menubar_draw (menubar);
 298 }
 299 
 300 /* --------------------------------------------------------------------------------------------- */
 301 
 302 static void
 303 menubar_right (WMenuBar * menubar)
     /*   */
 304 {
 305     menubar_remove (menubar);
 306     menubar->current = (menubar->current + 1) % g_list_length (menubar->menu);
 307     menubar_draw (menubar);
 308 }
 309 
 310 /* --------------------------------------------------------------------------------------------- */
 311 
 312 static void
 313 menubar_finish (WMenuBar * menubar)
     /*   */
 314 {
 315     Widget *w = WIDGET (menubar);
 316 
 317     menubar->is_dropped = FALSE;
 318     w->rect.lines = 1;
 319     widget_want_hotkey (w, FALSE);
 320     widget_set_options (w, WOP_SELECTABLE, FALSE);
 321 
 322     if (!mc_global.keybar_visible)
 323         widget_hide (w);
 324     else
 325     {
 326         /* Move the menubar to the bottom so that widgets displayed on top of
 327          * an "invisible" menubar get the first chance to respond to mouse events. */
 328         widget_set_bottom (w);
 329     }
 330 
 331     /* background must be bottom */
 332     if (DIALOG (w->owner)->bg != NULL)
 333         widget_set_bottom (WIDGET (DIALOG (w->owner)->bg));
 334 
 335     group_select_widget_by_id (w->owner, menubar->previous_widget);
 336     do_refresh ();
 337 }
 338 
 339 /* --------------------------------------------------------------------------------------------- */
 340 
 341 static void
 342 menubar_drop (WMenuBar * menubar, unsigned int selected)
     /*   */
 343 {
 344     menubar->is_dropped = TRUE;
 345     menubar->current = selected;
 346     menubar_draw (menubar);
 347 }
 348 
 349 /* --------------------------------------------------------------------------------------------- */
 350 
 351 static void
 352 menubar_execute (WMenuBar * menubar)
     /*   */
 353 {
 354     const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 355     const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
 356 
 357     if ((entry != NULL) && (entry->command != CK_IgnoreKey))
 358     {
 359         Widget *w = WIDGET (menubar);
 360 
 361         mc_global.widget.is_right = (menubar->current != 0);
 362         menubar_finish (menubar);
 363         send_message (w->owner, w, MSG_ACTION, entry->command, NULL);
 364         do_refresh ();
 365     }
 366 }
 367 
 368 /* --------------------------------------------------------------------------------------------- */
 369 
 370 static void
 371 menubar_down (WMenuBar * menubar)
     /*   */
 372 {
 373     menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 374     const unsigned int len = g_list_length (menu->entries);
 375     menu_entry_t *entry;
 376 
 377     menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
 378 
 379     do
 380     {
 381         menu->current = (menu->current + 1) % len;
 382         entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
 383     }
 384     while ((entry == NULL) || (entry->command == CK_IgnoreKey));
 385 
 386     menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
 387 }
 388 
 389 /* --------------------------------------------------------------------------------------------- */
 390 
 391 static void
 392 menubar_up (WMenuBar * menubar)
     /*   */
 393 {
 394     menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 395     const unsigned int len = g_list_length (menu->entries);
 396     menu_entry_t *entry;
 397 
 398     menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
 399 
 400     do
 401     {
 402         if (menu->current == 0)
 403             menu->current = len - 1;
 404         else
 405             menu->current--;
 406         entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
 407     }
 408     while ((entry == NULL) || (entry->command == CK_IgnoreKey));
 409 
 410     menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
 411 }
 412 
 413 /* --------------------------------------------------------------------------------------------- */
 414 
 415 static void
 416 menubar_first (WMenuBar * menubar)
     /*   */
 417 {
 418     if (menubar->is_dropped)
 419     {
 420         menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 421 
 422         if (menu->current == 0)
 423             return;
 424 
 425         menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
 426 
 427         menu->current = 0;
 428 
 429         while (TRUE)
 430         {
 431             menu_entry_t *entry;
 432 
 433             entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
 434 
 435             if ((entry == NULL) || (entry->command == CK_IgnoreKey))
 436                 menu->current++;
 437             else
 438                 break;
 439         }
 440 
 441         menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
 442     }
 443     else
 444     {
 445         menubar->current = 0;
 446         menubar_draw (menubar);
 447     }
 448 }
 449 
 450 /* --------------------------------------------------------------------------------------------- */
 451 
 452 static void
 453 menubar_last (WMenuBar * menubar)
     /*   */
 454 {
 455     if (menubar->is_dropped)
 456     {
 457         menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 458         const unsigned int len = g_list_length (menu->entries);
 459         menu_entry_t *entry;
 460 
 461         if (menu->current == len - 1)
 462             return;
 463 
 464         menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
 465 
 466         menu->current = len;
 467 
 468         do
 469         {
 470             menu->current--;
 471             entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
 472         }
 473         while ((entry == NULL) || (entry->command == CK_IgnoreKey));
 474 
 475         menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
 476     }
 477     else
 478     {
 479         menubar->current = g_list_length (menubar->menu) - 1;
 480         menubar_draw (menubar);
 481     }
 482 }
 483 
 484 /* --------------------------------------------------------------------------------------------- */
 485 
 486 static cb_ret_t
 487 menubar_try_drop_menu (WMenuBar * menubar, int hotkey)
     /*   */
 488 {
 489     GList *i;
 490 
 491     for (i = menubar->menu; i != NULL; i = g_list_next (i))
 492     {
 493         menu_t *menu = MENU (i->data);
 494 
 495         if (menu->text.hotkey != NULL && hotkey == g_ascii_tolower (menu->text.hotkey[0]))
 496         {
 497             menubar_drop (menubar, g_list_position (menubar->menu, i));
 498             return MSG_HANDLED;
 499         }
 500     }
 501 
 502     return MSG_NOT_HANDLED;
 503 }
 504 
 505 /* --------------------------------------------------------------------------------------------- */
 506 
 507 static cb_ret_t
 508 menubar_try_exec_menu (WMenuBar * menubar, int hotkey)
     /*   */
 509 {
 510     menu_t *menu;
 511     GList *i;
 512 
 513     menu = g_list_nth_data (menubar->menu, menubar->current);
 514 
 515     for (i = menu->entries; i != NULL; i = g_list_next (i))
 516     {
 517         const menu_entry_t *entry = MENUENTRY (i->data);
 518 
 519         if (entry != NULL && entry->text.hotkey != NULL
 520             && hotkey == g_ascii_tolower (entry->text.hotkey[0]))
 521         {
 522             menu->current = g_list_position (menu->entries, i);
 523             menubar_execute (menubar);
 524             return MSG_HANDLED;
 525         }
 526     }
 527 
 528     return MSG_NOT_HANDLED;
 529 }
 530 
 531 /* --------------------------------------------------------------------------------------------- */
 532 
 533 static void
 534 menubar_help (const WMenuBar * menubar)
     /*   */
 535 {
 536     ev_help_t event_data;
 537 
 538     event_data.filename = NULL;
 539 
 540     if (menubar->is_dropped)
 541         event_data.node = MENU (g_list_nth_data (menubar->menu, menubar->current))->help_node;
 542     else
 543         event_data.node = "[Menu Bar]";
 544 
 545     mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
 546     menubar_draw (menubar);
 547 }
 548 
 549 /* --------------------------------------------------------------------------------------------- */
 550 
 551 static cb_ret_t
 552 menubar_execute_cmd (WMenuBar * menubar, long command)
     /*   */
 553 {
 554     cb_ret_t ret = MSG_HANDLED;
 555 
 556     switch (command)
 557     {
 558     case CK_Help:
 559         menubar_help (menubar);
 560         break;
 561 
 562     case CK_Left:
 563         menubar_left (menubar);
 564         break;
 565     case CK_Right:
 566         menubar_right (menubar);
 567         break;
 568     case CK_Up:
 569         if (menubar->is_dropped)
 570             menubar_up (menubar);
 571         break;
 572     case CK_Down:
 573         if (menubar->is_dropped)
 574             menubar_down (menubar);
 575         else
 576             menubar_drop (menubar, menubar->current);
 577         break;
 578     case CK_Home:
 579         menubar_first (menubar);
 580         break;
 581     case CK_End:
 582         menubar_last (menubar);
 583         break;
 584 
 585     case CK_Enter:
 586         if (menubar->is_dropped)
 587             menubar_execute (menubar);
 588         else
 589             menubar_drop (menubar, menubar->current);
 590         break;
 591     case CK_Quit:
 592         menubar_finish (menubar);
 593         break;
 594 
 595     default:
 596         ret = MSG_NOT_HANDLED;
 597         break;
 598     }
 599 
 600     return ret;
 601 }
 602 
 603 /* --------------------------------------------------------------------------------------------- */
 604 
 605 static int
 606 menubar_handle_key (WMenuBar * menubar, int key)
     /*   */
 607 {
 608     long cmd;
 609     cb_ret_t ret = MSG_NOT_HANDLED;
 610 
 611     cmd = widget_lookup_key (WIDGET (menubar), key);
 612 
 613     if (cmd != CK_IgnoreKey)
 614         ret = menubar_execute_cmd (menubar, cmd);
 615 
 616     if (ret != MSG_HANDLED)
 617     {
 618         if (menubar->is_dropped)
 619             ret = menubar_try_exec_menu (menubar, key);
 620         else
 621             ret = menubar_try_drop_menu (menubar, key);
 622     }
 623 
 624     return ret;
 625 }
 626 
 627 /* --------------------------------------------------------------------------------------------- */
 628 
 629 static gboolean
 630 menubar_refresh (WMenuBar * menubar)
     /*   */
 631 {
 632     Widget *w = WIDGET (menubar);
 633 
 634     if (!widget_get_state (w, WST_FOCUSED))
 635         return FALSE;
 636 
 637     /* Trick to get all the mouse events */
 638     w->rect.lines = LINES;
 639 
 640     /* Trick to get all of the hotkeys */
 641     widget_want_hotkey (w, TRUE);
 642     return TRUE;
 643 }
 644 
 645 /* --------------------------------------------------------------------------------------------- */
 646 
 647 static inline void
 648 menubar_free_menu (WMenuBar * menubar)
     /*   */
 649 {
 650     g_clear_list (&menubar->menu, (GDestroyNotify) menu_free);
 651 }
 652 
 653 /* --------------------------------------------------------------------------------------------- */
 654 
 655 static cb_ret_t
 656 menubar_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
     /*   */
 657 {
 658     WMenuBar *menubar = MENUBAR (w);
 659 
 660     switch (msg)
 661     {
 662         /* We do not want the focus unless we have been activated */
 663     case MSG_FOCUS:
 664         if (menubar_refresh (menubar))
 665         {
 666             menubar_draw (menubar);
 667             return MSG_HANDLED;
 668         }
 669         return MSG_NOT_HANDLED;
 670 
 671     case MSG_UNFOCUS:
 672         return widget_get_state (w, WST_FOCUSED) ? MSG_NOT_HANDLED : MSG_HANDLED;
 673 
 674         /* We don't want the buttonbar to activate while using the menubar */
 675     case MSG_HOTKEY:
 676     case MSG_KEY:
 677         if (widget_get_state (w, WST_FOCUSED))
 678         {
 679             menubar_handle_key (menubar, parm);
 680             return MSG_HANDLED;
 681         }
 682         return MSG_NOT_HANDLED;
 683 
 684     case MSG_CURSOR:
 685         /* Put the cursor in a suitable place */
 686         return MSG_NOT_HANDLED;
 687 
 688     case MSG_DRAW:
 689         if (widget_get_state (w, WST_VISIBLE) || menubar_refresh (menubar))
 690             menubar_draw (menubar);
 691         return MSG_HANDLED;
 692 
 693     case MSG_RESIZE:
 694         /* try show menu after screen resize */
 695         widget_default_callback (w, NULL, MSG_RESIZE, 0, data);
 696         menubar_refresh (menubar);
 697         return MSG_HANDLED;
 698 
 699     case MSG_DESTROY:
 700         menubar_free_menu (menubar);
 701         return MSG_HANDLED;
 702 
 703     default:
 704         return widget_default_callback (w, sender, msg, parm, data);
 705     }
 706 }
 707 
 708 /* --------------------------------------------------------------------------------------------- */
 709 
 710 static unsigned int
 711 menubar_get_menu_by_x_coord (const WMenuBar * menubar, int x)
     /*   */
 712 {
 713     unsigned int i;
 714     GList *menu;
 715 
 716     for (i = 0, menu = menubar->menu;
 717          menu != NULL && x >= MENU (menu->data)->start_x; i++, menu = g_list_next (menu))
 718         ;
 719 
 720     /* Don't set the invalid value -1 */
 721     if (i != 0)
 722         i--;
 723 
 724     return i;
 725 }
 726 
 727 /* --------------------------------------------------------------------------------------------- */
 728 
 729 static gboolean
 730 menubar_mouse_on_menu (const WMenuBar * menubar, int y, int x)
     /*   */
 731 {
 732     const WRect *w = &CONST_WIDGET (menubar)->rect;
 733     menu_t *menu;
 734     int left_x, right_x, bottom_y;
 735 
 736     if (!menubar->is_dropped)
 737         return FALSE;
 738 
 739     menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 740     left_x = menu->start_x;
 741     right_x = left_x + menu->max_entry_len + 3;
 742     if (right_x > w->cols)
 743     {
 744         left_x = w->cols - (menu->max_entry_len + 3);
 745         right_x = w->cols;
 746     }
 747 
 748     bottom_y = g_list_length (menu->entries) + 2;       /* skip bar and top frame */
 749 
 750     return (x >= left_x && x < right_x && y > 1 && y < bottom_y);
 751 }
 752 
 753 /* --------------------------------------------------------------------------------------------- */
 754 
 755 static void
 756 menubar_change_selected_item (WMenuBar * menubar, int y)
     /*   */
 757 {
 758     menu_t *menu;
 759     menu_entry_t *entry;
 760 
 761     y -= 2;                     /* skip bar and top frame */
 762     menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
 763     entry = MENUENTRY (g_list_nth_data (menu->entries, y));
 764 
 765     if (entry != NULL && entry->command != CK_IgnoreKey)
 766     {
 767         menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
 768         menu->current = y;
 769         menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
 770     }
 771 }
 772 
 773 /* --------------------------------------------------------------------------------------------- */
 774 
 775 static void
 776 menubar_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
     /*   */
 777 {
 778     static gboolean was_drag = FALSE;
 779 
 780     WMenuBar *menubar = MENUBAR (w);
 781     gboolean mouse_on_drop;
 782 
 783     mouse_on_drop = menubar_mouse_on_menu (menubar, event->y, event->x);
 784 
 785     switch (msg)
 786     {
 787     case MSG_MOUSE_DOWN:
 788         was_drag = FALSE;
 789 
 790         if (event->y == 0)
 791         {
 792             /* events on menubar */
 793             unsigned int selected;
 794 
 795             selected = menubar_get_menu_by_x_coord (menubar, event->x);
 796             menubar_activate (menubar, TRUE, selected);
 797             menubar_remove (menubar);   /* if already shown */
 798             menubar_drop (menubar, selected);
 799         }
 800         else if (mouse_on_drop)
 801             menubar_change_selected_item (menubar, event->y);
 802         else
 803         {
 804             /* mouse click outside menubar or dropdown -- close menu */
 805             menubar_finish (menubar);
 806 
 807             /*
 808              * @FIXME.
 809              *
 810              * Unless we clear the 'capture' flag, we'll receive MSG_MOUSE_DRAG
 811              * events belonging to this click (in case the user drags the mouse,
 812              * of course).
 813              *
 814              * For the time being, we mark this with FIXME as this flag should
 815              * preferably be regarded as "implementation detail" and not be
 816              * touched by us. We should think of some other way of communicating
 817              * this to the system.
 818              */
 819             w->mouse.capture = FALSE;
 820         }
 821         break;
 822 
 823     case MSG_MOUSE_UP:
 824         if (was_drag && mouse_on_drop)
 825             menubar_execute (menubar);
 826         was_drag = FALSE;
 827         break;
 828 
 829     case MSG_MOUSE_CLICK:
 830         was_drag = FALSE;
 831 
 832         if ((event->buttons & GPM_B_MIDDLE) != 0 && event->y > 0 && menubar->is_dropped)
 833         {
 834             /* middle click -- everywhere */
 835             menubar_execute (menubar);
 836         }
 837         else if (mouse_on_drop)
 838             menubar_execute (menubar);
 839         else if (event->y > 0)
 840             /* releasing the mouse button outside the menu -- close menu */
 841             menubar_finish (menubar);
 842         break;
 843 
 844     case MSG_MOUSE_DRAG:
 845         if (event->y == 0)
 846         {
 847             menubar_remove (menubar);
 848             menubar_drop (menubar, menubar_get_menu_by_x_coord (menubar, event->x));
 849         }
 850         else if (mouse_on_drop)
 851             menubar_change_selected_item (menubar, event->y);
 852 
 853         was_drag = TRUE;
 854         break;
 855 
 856     case MSG_MOUSE_SCROLL_UP:
 857     case MSG_MOUSE_SCROLL_DOWN:
 858         was_drag = FALSE;
 859 
 860         if (widget_get_state (w, WST_FOCUSED))
 861         {
 862             if (event->y == 0)
 863             {
 864                 /* menubar: left/right */
 865                 if (msg == MSG_MOUSE_SCROLL_UP)
 866                     menubar_left (menubar);
 867                 else
 868                     menubar_right (menubar);
 869             }
 870             else if (mouse_on_drop)
 871             {
 872                 /* drop-down menu: up/down */
 873                 if (msg == MSG_MOUSE_SCROLL_UP)
 874                     menubar_up (menubar);
 875                 else
 876                     menubar_down (menubar);
 877             }
 878         }
 879         break;
 880 
 881     default:
 882         was_drag = FALSE;
 883         break;
 884     }
 885 }
 886 
 887 /* --------------------------------------------------------------------------------------------- */
 888 /*** public functions ****************************************************************************/
 889 /* --------------------------------------------------------------------------------------------- */
 890 
 891 menu_entry_t *
 892 menu_entry_new (const char *name, long command)
     /*   */
 893 {
 894     menu_entry_t *entry;
 895 
 896     entry = g_new (menu_entry_t, 1);
 897     entry->first_letter = ' ';
 898     entry->text = hotkey_new (name);
 899     entry->command = command;
 900     entry->shortcut = NULL;
 901 
 902     return entry;
 903 }
 904 
 905 /* --------------------------------------------------------------------------------------------- */
 906 
 907 void
 908 menu_entry_free (menu_entry_t * entry)
     /*   */
 909 {
 910     if (entry != NULL)
 911     {
 912         hotkey_free (entry->text);
 913         g_free (entry->shortcut);
 914         g_free (entry);
 915     }
 916 }
 917 
 918 /* --------------------------------------------------------------------------------------------- */
 919 
 920 menu_t *
 921 menu_new (const char *name, GList * entries, const char *help_node)
     /*   */
 922 {
 923     menu_t *menu;
 924 
 925     menu = g_new (menu_t, 1);
 926     menu->start_x = 0;
 927     menu->text = hotkey_new (name);
 928     menu->entries = entries;
 929     menu->max_entry_len = 1;
 930     menu->max_hotkey_len = 0;
 931     menu->current = 0;
 932     menu->help_node = g_strdup (help_node);
 933 
 934     return menu;
 935 }
 936 
 937 /* --------------------------------------------------------------------------------------------- */
 938 
 939 void
 940 menu_set_name (menu_t * menu, const char *name)
     /*   */
 941 {
 942     hotkey_free (menu->text);
 943     menu->text = hotkey_new (name);
 944 }
 945 
 946 /* --------------------------------------------------------------------------------------------- */
 947 
 948 void
 949 menu_free (menu_t * menu)
     /*   */
 950 {
 951     hotkey_free (menu->text);
 952     g_list_free_full (menu->entries, (GDestroyNotify) menu_entry_free);
 953     g_free (menu->help_node);
 954     g_free (menu);
 955 }
 956 
 957 /* --------------------------------------------------------------------------------------------- */
 958 
 959 WMenuBar *
 960 menubar_new (GList * menu)
     /*   */
 961 {
 962     WRect r = { 0, 0, 1, COLS };
 963     WMenuBar *menubar;
 964     Widget *w;
 965 
 966     menubar = g_new0 (WMenuBar, 1);
 967     w = WIDGET (menubar);
 968     widget_init (w, &r, menubar_callback, menubar_mouse_callback);
 969     w->pos_flags = WPOS_KEEP_HORZ | WPOS_KEEP_TOP;
 970     w->options |= WOP_TOP_SELECT;
 971     w->keymap = menu_map;
 972     menubar_set_menu (menubar, menu);
 973 
 974     return menubar;
 975 }
 976 
 977 /* --------------------------------------------------------------------------------------------- */
 978 
 979 void
 980 menubar_set_menu (WMenuBar * menubar, GList * menu)
     /*   */
 981 {
 982     /* delete previous menu */
 983     menubar_free_menu (menubar);
 984     /* add new menu */
 985     menubar->is_dropped = FALSE;
 986     menubar->menu = menu;
 987     menubar->current = 0;
 988     menubar_arrange (menubar);
 989     widget_set_state (WIDGET (menubar), WST_FOCUSED, FALSE);
 990 }
 991 
 992 /* --------------------------------------------------------------------------------------------- */
 993 
 994 void
 995 menubar_add_menu (WMenuBar * menubar, menu_t * menu)
     /*   */
 996 {
 997     if (menu != NULL)
 998     {
 999         menu_arrange (menu, DIALOG (WIDGET (menubar)->owner)->get_shortcut);
1000         menubar->menu = g_list_append (menubar->menu, menu);
1001     }
1002 
1003     menubar_arrange (menubar);
1004 }
1005 
1006 /* --------------------------------------------------------------------------------------------- */
1007 /**
1008  * Properly space menubar items. Should be called when menubar is created
1009  * and also when widget width is changed (i.e. upon xterm resize).
1010  */
1011 
1012 void
1013 menubar_arrange (WMenuBar * menubar)
     /*   */
1014 {
1015     int start_x = 1;
1016     GList *i;
1017     int gap;
1018 
1019     if (menubar->menu == NULL)
1020         return;
1021 
1022     gap = WIDGET (menubar)->rect.cols - 2;
1023 
1024     /* First, calculate gap between items... */
1025     for (i = menubar->menu; i != NULL; i = g_list_next (i))
1026     {
1027         menu_t *menu = MENU (i->data);
1028 
1029         /* preserve length here, to be used below */
1030         menu->start_x = hotkey_width (menu->text) + 2;
1031         gap -= menu->start_x;
1032     }
1033 
1034     if (g_list_next (menubar->menu) == NULL)
1035         gap = 1;
1036     else
1037         gap /= (g_list_length (menubar->menu) - 1);
1038 
1039     if (gap <= 0)
1040     {
1041         /* We are out of luck - window is too narrow... */
1042         gap = 1;
1043     }
1044     else if (gap >= 3)
1045         gap = 3;
1046 
1047     /* ...and now fix start positions of menubar items */
1048     for (i = menubar->menu; i != NULL; i = g_list_next (i))
1049     {
1050         menu_t *menu = MENU (i->data);
1051         int len = menu->start_x;
1052 
1053         menu->start_x = start_x;
1054         start_x += len + gap;
1055     }
1056 }
1057 
1058 /* --------------------------------------------------------------------------------------------- */
1059 /** Find MenuBar widget in the dialog */
1060 
1061 WMenuBar *
1062 menubar_find (const WDialog * h)
     /*   */
1063 {
1064     return MENUBAR (widget_find_by_type (CONST_WIDGET (h), menubar_callback));
1065 }
1066 
1067 /* --------------------------------------------------------------------------------------------- */
1068 
1069 /**
1070  * Activate menu bar.
1071  *
1072  * @param menubar menu bar object
1073  * @param dropped whether dropdown menus should be drooped or not
1074  * @which number of active dropdown menu
1075  */
1076 void
1077 menubar_activate (WMenuBar * menubar, gboolean dropped, int which)
     /*   */
1078 {
1079     Widget *w = WIDGET (menubar);
1080 
1081     widget_show (w);
1082 
1083     if (!widget_get_state (w, WST_FOCUSED))
1084     {
1085         widget_set_options (w, WOP_SELECTABLE, TRUE);
1086 
1087         menubar->is_dropped = dropped;
1088         if (which >= 0)
1089             menubar->current = (guint) which;
1090 
1091         menubar->previous_widget = group_get_current_widget_id (w->owner);
1092 
1093         /* Bring it to the top so it receives all mouse events before any other widget.
1094          * See also comment in menubar_finish(). */
1095         widget_select (w);
1096     }
1097 }
1098 
1099 /* --------------------------------------------------------------------------------------------- */
/* */
root/lib/widget/menu.c

DEFINITIONS
