apps/menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Robert E. Hak
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 /*
  22 2005 Kevin Ferrare :
  23  - Multi screen support
  24  - Rewrote/removed a lot of code now useless with the new gui API
  25 */
  26 #include <stdbool.h>
  27 #include <stdlib.h>
  28 #include "config.h"
  29 #include "system.h"
  30
  31 #include "lcd.h"
  32 #include "font.h"
  33 #include "backlight.h"
  34 #include "menu.h"
  35 #include "button.h"
  36 #include "kernel.h"
  37 #include "debug.h"
  38 #include "usb.h"
  39 #include "panic.h"
  40 #include "settings.h"
  41 #include "settings_list.h"
  42 #include "option_select.h"
  43 #include "status.h"
  44 #include "screens.h"
  45 #include "talk.h"
  46 #include "lang.h"
  47 #include "misc.h"
  48 #include "action.h"
  49 #include "menus/exported_menus.h"
  50 #include "string.h"
  51 #include "root_menu.h"
  52 #include "bookmark.h"
  53 #include "gwps-common.h" /* for fade() */
  54 #include "audio.h"
  55 #include "viewport.h"
  56 #include "quickscreen.h"
  57
  58 #ifdef HAVE_LCD_BITMAP
  59 #include "icons.h"
  60 #endif
  61
  62 /* gui api */
  63 #include "list.h"
  64 #include "statusbar.h"
  65 #include "buttonbar.h"
  66
  67 #define MAX_MENUS 8
  68 /* used to allow for dynamic menus */
  69 #define MAX_MENU_SUBITEMS 64
  70 static struct menu_item_ex *current_submenus_menu;
  71 static int current_subitems[MAX_MENU_SUBITEMS];
  72 static int current_subitems_count = 0;
  73 static int talk_menu_item(int selected_item, void *data);
  74
  75 static void get_menu_callback(const struct menu_item_ex *m,
  76                         menu_callback_type *menu_callback)
  77 {
  78     if (m->flags&(MENU_HAS_DESC|MENU_DYNAMIC_DESC))
  79         *menu_callback= m->callback_and_desc->menu_callback;
  80     else
  81         *menu_callback = m->menu_callback;
  82 }
  83
  84 static int get_menu_selection(int selected_item, const struct menu_item_ex *menu)
  85 {
  86     int type = (menu->flags&MENU_TYPE_MASK);
  87     if (type == MT_MENU && (selected_item<current_subitems_count))
  88         return current_subitems[selected_item];
  89     return selected_item;
  90 }
  91 static int find_menu_selection(int selected)
  92 {
  93     int i;
  94     for (i=0; i< current_subitems_count; i++)
  95         if (current_subitems[i] == selected)
  96             return i;
  97     return 0;
  98 }
  99 static char * get_menu_item_name(int selected_item,
 100                                  void * data,
 101                                  char *buffer,
 102                                  size_t buffer_len)
 103 {
 104     const struct menu_item_ex *menu = (const struct menu_item_ex *)data;
 105     int type = (menu->flags&MENU_TYPE_MASK);
 106     selected_item = get_menu_selection(selected_item, menu);
 107
 108     (void)buffer_len;
 109     /* only MT_MENU or MT_RETURN_ID is allowed in here */
 110     if (type == MT_RETURN_ID)
 111     {
 112         if (menu->flags&MENU_DYNAMIC_DESC)
 113             return menu->menu_get_name_and_icon->list_get_name(selected_item,
 114                     menu->menu_get_name_and_icon->list_get_name_data, buffer);
 115         return (char*)menu->strings[selected_item];
 116     }
 117
 118     menu = menu->submenus[selected_item];
 119
 120     if ((menu->flags&MENU_DYNAMIC_DESC) && (type != MT_SETTING_W_TEXT))
 121         return menu->menu_get_name_and_icon->list_get_name(selected_item,
 122                     menu->menu_get_name_and_icon->list_get_name_data, buffer);
 123
 124     type = (menu->flags&MENU_TYPE_MASK);
 125     if ((type == MT_SETTING) || (type == MT_SETTING_W_TEXT))
 126     {
 127         const struct settings_list *v
 128                 = find_setting(menu->variable, NULL);
 129         if (v)
 130             return str(v->lang_id);
 131         else return "Not Done yet!";
 132     }
 133     return P2STR(menu->callback_and_desc->desc);
 134 }
 135 #ifdef HAVE_LCD_BITMAP
 136 static int menu_get_icon(int selected_item, void * data)
 137 {
 138     const struct menu_item_ex *menu = (const struct menu_item_ex *)data;
 139     int menu_icon = Icon_NOICON;
 140     selected_item = get_menu_selection(selected_item, menu);
 141
 142     if ((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID)
 143     {
 144         return Icon_Menu_functioncall;
 145     }
 146     menu = menu->submenus[selected_item];
 147     if (menu->flags&MENU_HAS_DESC)
 148         menu_icon = menu->callback_and_desc->icon_id;
 149     else if (menu->flags&MENU_DYNAMIC_DESC)
 150         menu_icon = menu->menu_get_name_and_icon->icon_id;
 151
 152     if (menu_icon == Icon_NOICON)
 153     {
 154         switch (menu->flags&MENU_TYPE_MASK)
 155         {
 156             case MT_SETTING:
 157             case MT_SETTING_W_TEXT:
 158                 menu_icon = Icon_Menu_setting;
 159                 break;
 160             case MT_MENU:
 161                     menu_icon = Icon_Submenu;
 162                 break;
 163             case MT_FUNCTION_CALL:
 164             case MT_RETURN_VALUE:
 165                 menu_icon = Icon_Menu_functioncall;
 166                 break;
 167         }
 168     }
 169     return menu_icon;
 170 }
 171 #endif
 172
 173 static void init_menu_lists(const struct menu_item_ex *menu,
 174                      struct gui_synclist *lists, int selected, bool callback,
 175                      struct viewport parent[NB_SCREENS])
 176 {
 177     int i, count = MENU_GET_COUNT(menu->flags);
 178     int type = (menu->flags&MENU_TYPE_MASK);
 179     menu_callback_type menu_callback = NULL;
 180     int icon;
 181     current_subitems_count = 0;
 182
 183     if (type == MT_RETURN_ID)
 184         get_menu_callback(menu, &menu_callback);
 185
 186     for (i=0; i<count; i++)
 187     {
 188         if (type != MT_RETURN_ID)
 189             get_menu_callback(menu->submenus[i],&menu_callback);
 190         if (menu_callback)
 191         {
 192             if (menu_callback(ACTION_REQUEST_MENUITEM,
 193                     type==MT_RETURN_ID ? (void*)(intptr_t)i: menu->submenus[i])
 194                     != ACTION_EXIT_MENUITEM)
 195             {
 196                 current_subitems[current_subitems_count] = i;
 197                 current_subitems_count++;
 198             }
 199         }
 200         else
 201         {
 202             current_subitems[current_subitems_count] = i;
 203             current_subitems_count++;
 204         }
 205     }
 206     current_submenus_menu = (struct menu_item_ex *)menu;
 207
 208     gui_synclist_init(lists,get_menu_item_name,(void*)menu,false,1, parent);
 209 #ifdef HAVE_LCD_BITMAP
 210     if (menu->callback_and_desc->icon_id == Icon_NOICON)
 211         icon = Icon_Submenu_Entered;
 212     else
 213         icon = menu->callback_and_desc->icon_id;
 214     gui_synclist_set_title(lists, P2STR(menu->callback_and_desc->desc), icon);
 215     gui_synclist_set_icon_callback(lists, menu_get_icon);
 216 #else
 217     (void)icon;
 218     gui_synclist_set_icon_callback(lists, NULL);
 219 #endif
 220     if(global_settings.talk_menu)
 221         gui_synclist_set_voice_callback(lists, talk_menu_item);
 222     gui_synclist_set_nb_items(lists,current_subitems_count);
 223     gui_synclist_limit_scroll(lists,true);
 224     gui_synclist_select_item(lists, find_menu_selection(selected));
 225
 226     get_menu_callback(menu,&menu_callback);
 227     if (callback && menu_callback)
 228         menu_callback(ACTION_ENTER_MENUITEM,menu);
 229     gui_synclist_draw(lists);
 230     gui_synclist_speak_item(lists);
 231 }
 232
 233 static int talk_menu_item(int selected_item, void *data)
 234 {
 235     const struct menu_item_ex *menu = (const struct menu_item_ex *)data;
 236     int id = -1;
 237     int type;
 238     unsigned char *str;
 239     int sel = get_menu_selection(selected_item, menu);
 240
 241         if ((menu->flags&MENU_TYPE_MASK) == MT_MENU)
 242         {
 243             type = menu->submenus[sel]->flags&MENU_TYPE_MASK;
 244             if ((type == MT_SETTING) || (type == MT_SETTING_W_TEXT))
 245                 talk_setting(menu->submenus[sel]->variable);
 246             else
 247             {
 248                 if (menu->submenus[sel]->flags&(MENU_DYNAMIC_DESC))
 249                 {
 250                     int (*list_speak_item)(int selected_item, void * data)
 251                         = menu->submenus[sel]->menu_get_name_and_icon->
 252                         list_speak_item;
 253                     if(list_speak_item)
 254                         list_speak_item(sel, menu->submenus[sel]->
 255                                         menu_get_name_and_icon->
 256                                         list_get_name_data);
 257                     else
 258                     {
 259                         char buffer[80];
 260                         str = menu->submenus[sel]->menu_get_name_and_icon->
 261                             list_get_name(sel, menu->submenus[sel]->
 262                                           menu_get_name_and_icon->
 263                                           list_get_name_data, buffer);
 264                         id = P2ID(str);
 265                     }
 266                 }
 267                 else
 268                     id = P2ID(menu->submenus[sel]->callback_and_desc->desc);
 269                 if (id != -1)
 270                    talk_id(id,false);
 271             }
 272         }
 273         else if(((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID))
 274         {
 275             if ((menu->flags&MENU_DYNAMIC_DESC) == 0)
 276             {
 277                 unsigned char *s = (unsigned char *)menu->strings[sel];
 278                 /* string list, try to talk it if ID2P was used */
 279                 id = P2ID(s);
 280                 if (id != -1)
 281                     talk_id(id,false);
 282             }
 283         }
 284         return 0;
 285 }
 286 /* this is used to reload the default menu viewports when the
 287    theme changes. nothing happens if the menu is using a supplied parent vp */
 288 static void init_default_menu_viewports(struct viewport parent[NB_SCREENS], bool hide_bars)
 289 {
 290     int i;
 291     FOR_NB_SCREENS(i)
 292     {
 293         viewport_set_defaults(&parent[i], i);
 294         /* viewport_set_defaults() fixes the vp for the bars, so resize */
 295         if (hide_bars)
 296         {
 297             if (global_settings.statusbar)
 298             {
 299                 parent[i].y -= STATUSBAR_HEIGHT;
 300                 parent[i].height += STATUSBAR_HEIGHT;
 301             }
 302         }
 303     }
 304 #ifdef HAVE_BUTTONBAR
 305     if (!hide_bars && global_settings.buttonbar)
 306         parent[0].height -= BUTTONBAR_HEIGHT;
 307 #endif
 308 }
 309
 310 bool do_setting_from_menu(const struct menu_item_ex *temp,
 311                           struct viewport parent[NB_SCREENS])
 312 {
 313     int setting_id, oldval;
 314     const struct settings_list *setting = find_setting(
 315                                                temp->variable,
 316                                                &setting_id);
 317     char *title;
 318     char padded_title[MAX_PATH];
 319     int var_type = setting->flags&F_T_MASK;
 320     if (var_type == F_T_INT || var_type == F_T_UINT)
 321     {
 322         oldval = *(int*)setting->setting;
 323     }
 324     else if (var_type == F_T_BOOL)
 325     {
 326         oldval = *(bool*)setting->setting;
 327     }
 328     else
 329         oldval = 0;
 330     if ((temp->flags&MENU_TYPE_MASK) == MT_SETTING_W_TEXT)
 331         title = temp->callback_and_desc->desc;
 332     else
 333         title = ID2P(setting->lang_id);
 334
 335     /* Pad the title string by repeating it. This is needed
 336        so the scroll settings title can actually be used to
 337        test the setting */
 338     if (setting->flags&F_PADTITLE)
 339     {
 340         int i = 0, len;
 341         if (setting->lang_id == -1)
 342             title = (char*)setting->cfg_vals;
 343         else
 344             title = P2STR((unsigned char*)title);
 345         len = strlen(title);
 346         while (i < MAX_PATH-1)
 347         {
 348             int padlen = MIN(len, MAX_PATH-1-i);
 349             strncpy(&padded_title[i], title, padlen);
 350             i += padlen;
 351             if (i<MAX_PATH-1)
 352                 padded_title[i++] = ' ';
 353         }
 354         padded_title[i] = '\0';
 355         title = padded_title;
 356     }
 357
 358     option_screen((struct settings_list *)setting, parent,
 359                   setting->flags&F_TEMPVAR, title);
 360     if (var_type == F_T_INT || var_type == F_T_UINT)
 361     {
 362         return oldval != *(int*)setting->setting;
 363     }
 364     else if (var_type == F_T_BOOL)
 365     {
 366         return oldval != *(bool*)setting->setting;
 367     }
 368     return false;
 369 }
 370
 371 /* display a menu */
 372 int do_menu(const struct menu_item_ex *start_menu, int *start_selected,
 373             struct viewport parent[NB_SCREENS], bool hide_bars)
 374 {
 375     int selected = start_selected? *start_selected : 0;
 376     int action;
 377     struct gui_synclist lists;
 378     const struct menu_item_ex *temp, *menu;
 379     int ret = 0, i;
 380     bool redraw_lists;
 381
 382     const struct menu_item_ex *menu_stack[MAX_MENUS];
 383     int menu_stack_selected_item[MAX_MENUS];
 384     int stack_top = 0;
 385     bool in_stringlist, done = false;
 386
 387     struct viewport *vps, menu_vp[NB_SCREENS]; /* menu_vp will hopefully be phased out */
 388 #ifdef HAVE_BUTTONBAR
 389     struct gui_buttonbar buttonbar;
 390     gui_buttonbar_init(&buttonbar);
 391     gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
 392     gui_buttonbar_set(&buttonbar, "<<<", "", "");
 393 #endif
 394
 395     menu_callback_type menu_callback = NULL;
 396     if (start_menu == NULL)
 397         menu = &main_menu_;
 398     else menu = start_menu;
 399
 400     init_default_menu_viewports(menu_vp, hide_bars);
 401
 402     if (parent)
 403     {
 404         vps = parent;
 405         /* if hide_bars == true we assume the viewport is correctly sized */
 406     }
 407     else
 408     {
 409         vps = menu_vp;
 410     }
 411     FOR_NB_SCREENS(i)
 412     {
 413         screens[i].set_viewport(&vps[i]);
 414         screens[i].clear_viewport();
 415         screens[i].set_viewport(NULL);
 416     }
 417     init_menu_lists(menu, &lists, selected, true, vps);
 418     in_stringlist = ((menu->flags&MENU_TYPE_MASK) == MT_RETURN_ID);
 419
 420     /* load the callback, and only reload it if menu changes */
 421     get_menu_callback(menu, &menu_callback);
 422
 423
 424 #ifdef HAVE_BUTTONBAR
 425     if (!hide_bars)
 426     {
 427         gui_buttonbar_set(&buttonbar, "<<<", "", "");
 428         gui_buttonbar_draw(&buttonbar);
 429     }
 430 #endif
 431     while (!done)
 432     {
 433         redraw_lists = false;
 434         if (!hide_bars)
 435         {
 436 #ifdef HAVE_BUTTONBAR
 437             gui_buttonbar_draw(&buttonbar);
 438 #endif
 439             gui_syncstatusbar_draw(&statusbars, true);
 440         }
 441         action = get_action(CONTEXT_MAINMENU,
 442                             list_do_action_timeout(&lists, HZ));
 443         /* HZ so the status bar redraws corectly */
 444
 445         if (menu_callback)
 446         {
 447             int old_action = action;
 448             action = menu_callback(action, menu);
 449             if (action == ACTION_EXIT_AFTER_THIS_MENUITEM)
 450             {
 451                 action = old_action;
 452                 ret = MENU_SELECTED_EXIT; /* will exit after returning
 453                                              from selection */
 454             }
 455             else if (action == ACTION_REDRAW)
 456             {
 457                 action = old_action;
 458                 redraw_lists = true;
 459             }
 460         }
 461
 462         if (gui_synclist_do_button(&lists, &action, LIST_WRAP_UNLESS_HELD))
 463             continue;
 464         if (action == ACTION_NONE)
 465             continue;
 466 #ifdef HAVE_QUICKSCREEN
 467         else if (action == ACTION_STD_QUICKSCREEN)
 468         {
 469             quick_screen_quick(action);
 470             redraw_lists = true;
 471         }
 472 #endif
 473 #ifdef HAVE_RECORDING
 474         else if (action == ACTION_STD_REC)
 475         {
 476             ret = GO_TO_RECSCREEN;
 477             done = true;
 478         }
 479 #endif
 480         else if (action == ACTION_TREE_WPS)
 481         {
 482             ret = GO_TO_PREVIOUS_MUSIC;
 483             done = true;
 484         }
 485         else if (action == ACTION_TREE_STOP)
 486         {
 487             redraw_lists = list_stop_handler();
 488         }
 489         else if (action == ACTION_STD_CONTEXT)
 490         {
 491             if (menu == &root_menu_)
 492             {
 493                 ret = GO_TO_ROOTITEM_CONTEXT;
 494                 done = true;
 495             }
 496             else if (!in_stringlist)
 497             {
 498                 int type;
 499                 selected = get_menu_selection(gui_synclist_get_sel_pos(&lists), menu);
 500                 temp = menu->submenus[selected];
 501                 type = (temp->flags&MENU_TYPE_MASK);
 502                 if ((type == MT_SETTING_W_TEXT || type == MT_SETTING))
 503                 {
 504 #ifdef HAVE_QUICKSCREEN
 505                     MENUITEM_STRINGLIST(quickscreen_able_option,
 506                                         ID2P(LANG_ONPLAY_MENU_TITLE), NULL,
 507                                         ID2P(LANG_RESET_SETTING),
 508                                         ID2P(LANG_LEFT_QS_ITEM),
 509                                         ID2P(LANG_BOTTOM_QS_ITEM),
 510                                         ID2P(LANG_RIGHT_QS_ITEM));
 511 #endif
 512                     MENUITEM_STRINGLIST(notquickscreen_able_option,
 513                                         ID2P(LANG_ONPLAY_MENU_TITLE), NULL,
 514                                         ID2P(LANG_RESET_SETTING));
 515                     const struct menu_item_ex *menu;
 516                     int menu_selection = 0;
 517                     const struct settings_list *setting =
 518                             find_setting(temp->variable, NULL);
 519 #ifdef HAVE_QUICKSCREEN
 520                     if (is_setting_quickscreenable(setting))
 521                         menu = &quickscreen_able_option;
 522                     else
 523 #endif
 524                         menu = &notquickscreen_able_option;
 525                     switch (do_menu(menu, &menu_selection, NULL, false))
 526                     {
 527                         case GO_TO_PREVIOUS:
 528                             break;
 529                             case 0: /* reset setting */
 530                                 reset_setting(setting, setting->setting);
 531                                 break;
 532 #ifdef HAVE_QUICKSCREEN
 533                             break;
 534                         case 1: /* set as left QS item */
 535                             set_as_qs_item(setting, QUICKSCREEN_LEFT);
 536                             break;
 537                         case 2: /* set as bottom QS item */
 538                             set_as_qs_item(setting, QUICKSCREEN_BOTTOM);
 539                             break;
 540                         case 3: /* set as right QS item */
 541                             set_as_qs_item(setting, QUICKSCREEN_RIGHT);
 542                             break;
 543 #endif
 544                     } /* swicth(do_menu()) */
 545                     redraw_lists = true;
 546                 }
 547             } /* else if (!in_stringlist) */
 548         }
 549         else if (action == ACTION_STD_MENU)
 550         {
 551             if (menu != &root_menu_)
 552                 ret = GO_TO_ROOT;
 553             else
 554                 ret = GO_TO_PREVIOUS;
 555             done = true;
 556         }
 557         else if (action == ACTION_STD_CANCEL)
 558         {
 559             bool exiting_menu = false;
 560             in_stringlist = false;
 561             /* might be leaving list, so stop scrolling */
 562             FOR_NB_SCREENS(i)
 563             {
 564                 screens[i].stop_scroll();
 565             }
 566             if (menu_callback)
 567                 menu_callback(ACTION_EXIT_MENUITEM, menu);
 568
 569             if (menu->flags&MENU_EXITAFTERTHISMENU)
 570                 done = true;
 571             else if ((menu->flags&MENU_TYPE_MASK) == MT_MENU)
 572                 exiting_menu = true;
 573             if (stack_top > 0)
 574             {
 575                 stack_top--;
 576                 menu = menu_stack[stack_top];
 577                 if (!exiting_menu && (menu->flags&MENU_EXITAFTERTHISMENU))
 578                     done = true;
 579                 else
 580                     init_menu_lists(menu, &lists,
 581                                     menu_stack_selected_item[stack_top], false, vps);
 582                 /* new menu, so reload the callback */
 583                 get_menu_callback(menu, &menu_callback);
 584             }
 585             else if (menu != &root_menu_)
 586             {
 587                 ret = GO_TO_PREVIOUS;
 588                 done = true;
 589             }
 590         }
 591         else if (action == ACTION_STD_OK)
 592         {
 593             int type;
 594             /* entering an item that may not be a list, so stop scrolling */
 595             FOR_NB_SCREENS(i)
 596             {
 597                 screens[i].stop_scroll();
 598             }
 599 #ifdef HAVE_BUTTONBAR
 600             if (!hide_bars)
 601             {
 602                 gui_buttonbar_unset(&buttonbar);
 603                 gui_buttonbar_draw(&buttonbar);
 604             }
 605 #endif
 606             selected = get_menu_selection(gui_synclist_get_sel_pos(&lists), menu);
 607             temp = menu->submenus[selected];
 608             redraw_lists = true;
 609             if (in_stringlist)
 610                 type = (menu->flags&MENU_TYPE_MASK);
 611             else
 612             {
 613                 type = (temp->flags&MENU_TYPE_MASK);
 614                 get_menu_callback(temp, &menu_callback);
 615                 if (menu_callback)
 616                 {
 617                     action = menu_callback(ACTION_ENTER_MENUITEM,temp);
 618                     if (action == ACTION_EXIT_MENUITEM)
 619                         break;
 620                 }
 621             }
 622             switch (type)
 623             {
 624                 case MT_MENU:
 625                     if (stack_top < MAX_MENUS)
 626                     {
 627                         menu_stack[stack_top] = menu;
 628                         menu_stack_selected_item[stack_top] = selected;
 629                         stack_top++;
 630                         init_menu_lists(temp, &lists, 0, true, vps);
 631                         redraw_lists = false; /* above does the redraw */
 632                         menu = temp;
 633                     }
 634                     break;
 635                 case MT_FUNCTION_CALL:
 636                 {
 637                     int return_value;
 638                     if (temp->flags&MENU_FUNC_USEPARAM)
 639                         return_value = temp->function->function_w_param(
 640                                     temp->function->param);
 641                     else
 642                         return_value = temp->function->function();
 643                     if (!(menu->flags&MENU_EXITAFTERTHISMENU) || (temp->flags&MENU_EXITAFTERTHISMENU))
 644                     {
 645                         init_default_menu_viewports(menu_vp, hide_bars);
 646                         init_menu_lists(menu, &lists, selected, true, vps);
 647                     }
 648                     if (temp->flags&MENU_FUNC_CHECK_RETVAL)
 649                     {
 650                         if (return_value != 0)
 651                         {
 652                             done = true;
 653                             ret =  return_value;
 654                         }
 655                     }
 656                     break;
 657                 }
 658                 case MT_SETTING:
 659                 case MT_SETTING_W_TEXT:
 660                 {
 661                     if (do_setting_from_menu(temp, menu_vp))
 662                     {
 663                         init_default_menu_viewports(menu_vp, hide_bars);
 664                         init_menu_lists(menu, &lists, selected, true,vps);
 665                         redraw_lists = false; /* above does the redraw */
 666                     }
 667                     break;
 668                 }
 669                 case MT_RETURN_ID:
 670                     if (in_stringlist)
 671                     {
 672                         done = true;
 673                         ret =  selected;
 674                     }
 675                     else if (stack_top < MAX_MENUS)
 676                     {
 677                         menu_stack[stack_top] = menu;
 678                         menu_stack_selected_item[stack_top] = selected;
 679                         stack_top++;
 680                         menu = temp;
 681                         init_menu_lists(menu,&lists,0,false, vps);
 682                         redraw_lists = false; /* above does the redraw */
 683                         in_stringlist = true;
 684                     }
 685                     break;
 686                 case MT_RETURN_VALUE:
 687                     ret = temp->value;
 688                     done = true;
 689                     break;
 690             }
 691             if (type != MT_MENU)
 692             {
 693                 if (menu_callback)
 694                     menu_callback(ACTION_EXIT_MENUITEM,temp);
 695             }
 696             if (current_submenus_menu != menu)
 697                 init_menu_lists(menu,&lists,selected,true,vps);
 698             /* callback was changed, so reload the menu's callback */
 699             get_menu_callback(menu, &menu_callback);
 700             if ((menu->flags&MENU_EXITAFTERTHISMENU) &&
 701                 !(temp->flags&MENU_EXITAFTERTHISMENU))
 702             {
 703                 done = true;
 704                 break;
 705             }
 706 #ifdef HAVE_BUTTONBAR
 707             if (!hide_bars)
 708             {
 709                 gui_buttonbar_set(&buttonbar, "<<<", "", "");
 710                 gui_buttonbar_draw(&buttonbar);
 711             }
 712 #endif
 713         }
 714         else if(default_event_handler(action) == SYS_USB_CONNECTED)
 715         {
 716             ret = MENU_ATTACHED_USB;
 717             done = true;
 718         }
 719
 720         if (redraw_lists && !done)
 721         {
 722             if (menu_callback)
 723                 menu_callback(ACTION_REDRAW, menu);
 724             gui_synclist_draw(&lists);
 725             gui_synclist_speak_item(&lists);
 726         }
 727     }
 728     if (start_selected)
 729     {
 730         /* make sure the start_selected variable is set to
 731            the selected item from the menu do_menu() was called from */
 732         if (stack_top > 0)
 733         {
 734             menu = menu_stack[0];
 735             init_menu_lists(menu,&lists,menu_stack_selected_item[0],true, vps);
 736         }
 737         *start_selected = get_menu_selection(
 738                             gui_synclist_get_sel_pos(&lists), menu);
 739     }
 740     return ret;
 741 }
 742