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